Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,49 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz 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
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+model/test_results/test_run_20250702_143737/confidence_analysis.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_143737/confusion_matrix_absolute.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_143737/confusion_matrix_normalized.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_143737/per_class_metrics.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152814/confidence_analysis.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152814/confusion_matrix_absolute.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152814/confusion_matrix_normalized.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152814/per_class_metrics.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152925/confidence_analysis.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152925/confusion_matrix_absolute.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152925/confusion_matrix_normalized.png filter=lfs diff=lfs merge=lfs -text
+model/test_results/test_run_20250702_152925/per_class_metrics.png filter=lfs diff=lfs merge=lfs -text
+model/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+model/training_metrics.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+model/model.safetensors

DockerFile

@@ -0,0 +1,23 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system packages (nltk needs some)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy everything to container
+COPY . .
+
+# Install dependencies
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+
+# Download NLTK data
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('stopwords'); nltk.download('wordnet')"
+
+# Start app using gunicorn
+CMD [\"gunicorn\", \"-w\", \"4\", \"-b\", \"0.0.0.0:7860\", \"app:app\"]

app.py

@@ -0,0 +1,190 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import torch
+import numpy as np
+import pickle
+import os
+import json
+import logging
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+
+# Download necessary NLTK resources
+nltk.download('stopwords', quiet=True)
+nltk.download('punkt', quiet=True)
+nltk.download('wordnet', quiet=True)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)
+
+# Global variables and constants
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+INTENT_MODEL_PATH = os.path.join(BASE_DIR, "model")
+RECOMMENDER_MODEL_PATH = os.path.join(BASE_DIR, "recommender_model")
+
+intent_model = None
+intent_tokenizer = None
+intent_classes = None
+intent_thresholds = None
+recommender = None
+recommender_model_loaded = False
+
+class BookRecommender:
+    def __init__(self, model_name='all-minilm-l6-v2'):
+        self.model_name = model_name
+        self.model = None
+        self.book_embeddings = None
+        self.df = None
+        self.stop_words = set(stopwords.words('english'))
+        self.lemmatizer = WordNetLemmatizer()
+
+    def preprocess_text(self, text):
+        if not isinstance(text, str):
+            return ""
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', ' ', text)
+        tokens = nltk.word_tokenize(text)
+        tokens = [self.lemmatizer.lemmatize(word) for word in tokens if word not in self.stop_words]
+        return ' '.join(tokens)
+
+    def load_model(self, folder_path=RECOMMENDER_MODEL_PATH):
+        try:
+            if not os.path.exists(folder_path):
+                return False
+            with open(os.path.join(folder_path, "config.pkl"), 'rb') as f:
+                config = pickle.load(f)
+            self.model_name = config['model_name']
+            self.model = SentenceTransformer(os.path.join(folder_path, "sentence_transformer"))
+            with open(os.path.join(folder_path, "book_embeddings.pkl"), 'rb') as f:
+                self.book_embeddings = pickle.load(f)
+            with open(os.path.join(folder_path, "books_data.pkl"), 'rb') as f:
+                self.df = pickle.load(f)
+            return True
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}", exc_info=True)
+            return False
+
+    def recommend_books(self, user_query, top_n=5, include_description=True):
+        if self.model is None or self.book_embeddings is None or self.df is None:
+            return []
+        try:
+            processed_query = self.preprocess_text(user_query)
+            user_embedding = self.model.encode([processed_query])
+            similarities = cosine_similarity(user_embedding, self.book_embeddings)[0]
+            similar_books_idx = np.argsort(similarities)[-top_n:][::-1]
+            recommendations = []
+            for i, idx in enumerate(similar_books_idx):
+                book_data = {
+                    'title': self.df.iloc[idx].get('Title', ''),
+                    'author': self.df.iloc[idx].get('Authors', ''),
+                    'category': self.df.iloc[idx].get('Category', ''),
+                    'year': self.df.iloc[idx].get('Publish Date (Year)', ''),
+                    'description': self.df.iloc[idx].get('Description', '')[:197] + "..." if include_description and 'Description' in self.df.columns else '',
+                    'relevance_score': float(similarities[idx]),
+                    'rank': i + 1
+                }
+                recommendations.append(book_data)
+            return recommendations
+        except Exception as e:
+            logger.error(f"Error generating recommendations: {str(e)}", exc_info=True)
+            return []
+
+
+def load_ood_thresholds(model_path):
+    threshold_path = os.path.join(model_path, "ood_thresholds.json")
+    if os.path.exists(threshold_path):
+        with open(threshold_path, "r") as f:
+            return json.load(f)
+    return {"energy_threshold": 0.0, "msp_threshold": 0.5}
+
+
+def load_intent_resources():
+    global intent_model, intent_tokenizer, intent_classes, intent_thresholds
+    try:
+        intent_model = AutoModelForSequenceClassification.from_pretrained("ZEROTSUDIOS/Bipa-Classification")
+        intent_tokenizer = AutoTokenizer.from_pretrained("ZEROTSUDIOS/Bipa-Classification")
+        with open(os.path.join(INTENT_MODEL_PATH, "intent_classes.pkl"), "rb") as f:
+            intent_classes = pickle.load(f)
+        intent_thresholds = load_ood_thresholds(INTENT_MODEL_PATH)
+        return True
+    except Exception as e:
+        logger.error(f"Failed to load intent resources: {str(e)}", exc_info=True)
+        return False
+
+
+def predict_intent(text, method='combined'):
+    inputs = intent_tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
+    with torch.no_grad():
+        outputs = intent_model(**inputs)
+        logits = outputs.logits
+    probs = torch.nn.functional.softmax(logits, dim=-1)
+    max_prob, pred_idx = torch.max(probs, dim=-1)
+    energy = -torch.logsumexp(logits, dim=-1)
+    is_ood = False
+    if method == 'energy':
+        is_ood = energy.item() > intent_thresholds['energy_threshold']
+    elif method == 'msp':
+        is_ood = max_prob.item() < intent_thresholds['msp_threshold']
+    elif method == 'combined':
+        is_ood = (energy.item() > intent_thresholds['energy_threshold']) and (max_prob.item() < intent_thresholds['msp_threshold'])
+    return {
+        "intent": intent_classes[pred_idx.item()],
+        "is_ood": is_ood,
+        "confidence": max_prob.item(),
+        "energy_score": energy.item()
+    }
+
+
+@app.route('/api/analyze', methods=['POST'])
+def analyze():
+    if not request.is_json:
+        return jsonify({"error": "Request must be JSON"}), 400
+    data = request.get_json()
+    text = data.get('text')
+    method = data.get('method', 'combined')
+    result = predict_intent(text, method)
+    return jsonify(result)
+
+
+@app.route('/api/recommend', methods=['POST'])
+def recommend():
+    global recommender_model_loaded
+    if not recommender_model_loaded:
+        return jsonify({"error": "Recommendation model not loaded."}), 503
+    data = request.get_json()
+    query = data.get('query')
+    top_n = data.get('top_n', 5)
+    include_description = data.get('include_description', True)
+    threshold = data.get('threshold', 0.5)
+    if not query:
+        return jsonify({"error": "Missing query."}), 400
+    recommendations = recommender.recommend_books(query, top_n=top_n, include_description=include_description)
+    high_score = [rec for rec in recommendations if rec['relevance_score'] >= threshold]
+    low_score = [rec for rec in recommendations if rec['relevance_score'] < threshold]
+    return jsonify({
+        "query": query,
+        "threshold": threshold,
+        "high_recommendations": high_score,
+        "low_recommendations": low_score,
+        "total_count": len(recommendations),
+        "high_count": len(high_score),
+        "low_count": len(low_score)
+    })
+
+
+if __name__ == '__main__':
+    load_intent_resources()
+    recommender = BookRecommender()
+    recommender_model_loaded = recommender.load_model()
+    port = int(os.environ.get('PORT', 5000))
+    app.run(host='0.0.0.0', port=port, debug=False, use_reloader=False)

app2.py

@@ -0,0 +1,460 @@
+from flask import Flask, request, jsonify
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import pickle
+import torch
+import numpy as np
+import pandas as pd
+import os
+import json
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+import logging
+from flask_cors import CORS
+
+# Configure logging
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    handlers=[logging.FileHandler("api.log"),
+                              logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+# Download required NLTK resources (only needs to run once on server startup)
+try:
+    nltk.data.find('corpora/stopwords')
+    nltk.data.find('corpora/wordnet')
+    nltk.data.find('corpora/punkt')
+except LookupError:
+    nltk.download('stopwords')
+    nltk.download('wordnet')
+    nltk.download('punkt')
+
+app = Flask(__name__)
+CORS(app)  # Enable Cross-Origin Resource Sharing
+
+# Global variables for intent classification
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODEL_SAVE_PATH = os.path.join(BASE_DIR, "model")
+intent_model = None
+intent_tokenizer = None
+intent_classes = None
+intent_thresholds = None
+
+class BookRecommender:
+    def __init__(self, model_name='all-minilm-l6-v2'):
+        """Initialize the book recommender with specified model."""
+        self.model_name = model_name
+        self.model = None
+        self.book_embeddings = None
+        self.df = None
+        self.stop_words = set(stopwords.words('english'))
+        self.lemmatizer = WordNetLemmatizer()
+        logger.info(f"BookRecommender initialized with model: {model_name}")
+        
+    def preprocess_text(self, text):
+        """Advanced text preprocessing with stopword removal and lemmatization."""
+        if not isinstance(text, str):
+            return ""
+            
+        # Convert to lowercase and remove special characters
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', ' ', text)
+        
+        # Tokenize, remove stopwords, and lemmatize
+        tokens = nltk.word_tokenize(text)
+        tokens = [self.lemmatizer.lemmatize(word) for word in tokens if word not in self.stop_words]
+        
+        return ' '.join(tokens)
+
+    def load_model(self, folder_path="recommender_model"):
+        """Load a previously saved model and embeddings for inference."""
+        try:
+            # Check if folder exists
+            if not os.path.exists(folder_path):
+                logger.error(f"Model folder {folder_path} does not exist.")
+                return False
+                
+            # Load configuration
+            config_path = os.path.join(folder_path, "config.pkl")
+            with open(config_path, 'rb') as f:
+                config = pickle.load(f)
+            self.model_name = config['model_name']
+            logger.info(f"Loaded configuration: model_name={self.model_name}")
+            
+            # Load the sentence transformer model
+            model_path = os.path.join(folder_path, "sentence_transformer")
+            self.model = SentenceTransformer(model_path)
+            logger.info(f"Model loaded from {model_path}")
+            
+            # Load book embeddings
+            embeddings_path = os.path.join(folder_path, "book_embeddings.pkl")
+            with open(embeddings_path, 'rb') as f:
+                self.book_embeddings = pickle.load(f)
+            logger.info(f"Embeddings loaded: {len(self.book_embeddings)} book vectors")
+            
+            # Load the DataFrame
+            df_path = os.path.join(folder_path, "books_data.pkl")
+            with open(df_path, 'rb') as f:
+                self.df = pickle.load(f)
+            logger.info(f"DataFrame loaded: {len(self.df)} books")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}", exc_info=True)
+            return False
+
+    def recommend_books(self, user_query, top_n=5, include_description=True):
+        """Recommend books based on user query."""
+        if self.model is None or self.book_embeddings is None or self.df is None:
+            logger.error("Model not initialized. Cannot make recommendations.")
+            return []
+            
+        logger.info(f"Finding books similar to: '{user_query}'")
+        
+        try:
+            # Preprocess the query the same way as the book text
+            processed_query = self.preprocess_text(user_query)
+            
+            # Encode user query
+            user_embedding = self.model.encode([processed_query])
+            
+            # Compute similarity between query and books
+            similarities = cosine_similarity(user_embedding, self.book_embeddings)[0]
+            
+            # Get top N most similar books
+            similar_books_idx = np.argsort(similarities)[-top_n:][::-1]
+            
+            recommendations = []
+            
+            for i, idx in enumerate(similar_books_idx):
+                book_data = {}
+                
+                # Extract book information
+                if 'Title' in self.df.columns:
+                    book_data['title'] = self.df.iloc[idx]['Title']
+                
+                if 'Authors' in self.df.columns:
+                    book_data['author'] = self.df.iloc[idx]['Authors']
+                
+                if 'Category' in self.df.columns:
+                    book_data['category'] = self.df.iloc[idx]['Category']
+                
+                if 'Publish Date (Year)' in self.df.columns:
+                    book_data['year'] = self.df.iloc[idx]['Publish Date (Year)']
+                    
+                if include_description and 'Description' in self.df.columns:
+                    # Truncate long descriptions
+                    description = self.df.iloc[idx]['Description']
+                    if len(description) > 200:
+                        description = description[:197] + "..."
+                    book_data['description'] = description
+                
+                # Add similarity score
+                book_data['relevance_score'] = float(similarities[idx])
+                book_data['rank'] = i + 1
+                
+                recommendations.append(book_data)
+            
+            logger.info(f"Successfully generated {len(recommendations)} recommendations")
+            return recommendations
+            
+        except Exception as e:
+            logger.error(f"Error generating recommendations: {str(e)}", exc_info=True)
+            return []
+
+# Initialize the recommender system
+recommender = BookRecommender()
+recommender_model_loaded = False
+
+def load_ood_thresholds(model_path):
+    """Load the OOD thresholds from the model directory - using JSON instead of pickle."""
+    # Look for JSON file instead of pickle
+    threshold_path = os.path.join(model_path, "ood_thresholds.json")
+    
+    # Check if file exists before attempting to open
+    if os.path.exists(threshold_path):
+        with open(threshold_path, "r") as f:
+            return json.load(f)
+    else:
+        # Provide default thresholds if file not found
+        logger.warning(f"Threshold file not found at {threshold_path}. Using default values.")
+        return {
+            "energy_threshold": 0.0,  # Replace with your default value
+            "msp_threshold": 0.5      # Replace with your default value
+        }
+
+def load_intent_resources():
+    """Load model, tokenizer, intent classes, and thresholds for intent classification."""
+    global intent_model, intent_tokenizer, intent_classes, intent_thresholds
+    
+    logger.info(f"Loading intent resources from {MODEL_SAVE_PATH}...")
+    
+    # Load model and tokenizer
+    intent_model = AutoModelForSequenceClassification.from_pretrained(MODEL_SAVE_PATH)
+    intent_tokenizer = AutoTokenizer.from_pretrained(MODEL_SAVE_PATH)
+    
+    # Load intent classes
+    intent_classes_path = os.path.join(MODEL_SAVE_PATH, "intent_classes.pkl")
+    if os.path.exists(intent_classes_path):
+        with open(intent_classes_path, "rb") as f:
+            intent_classes = pickle.load(f)
+    else:
+        raise FileNotFoundError(f"Intent classes file not found at {intent_classes_path}")
+    
+    # Load OOD thresholds
+    intent_thresholds = load_ood_thresholds(MODEL_SAVE_PATH)
+    
+    logger.info("Intent resources loaded successfully")
+    logger.info(f"Loaded {len(intent_classes)} intent classes")
+    logger.info(f"Thresholds: {intent_thresholds}")
+
+def predict_intent_with_enhanced_ood(text, model, tokenizer, intent_classes, 
+                                    energy_threshold, msp_threshold, method='combined'):
+    """
+    Predict intent with enhanced out-of-distribution detection and print details to terminal.
+    """
+    logger.info("\n========== INTENT PREDICTION DEBUG ==========")
+    logger.info(f"Input Text: {text}")
+    logger.info(f"Detection Method: {method}")
+    
+    # Tokenize input
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
+    
+    # Get model outputs
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+
+    logger.info(f"Logits: {logits.numpy().tolist()}")
+
+    # Get probabilities
+    probs = torch.nn.functional.softmax(logits, dim=-1)
+    max_prob, pred_idx = torch.max(probs, dim=-1)
+
+    logger.info(f"Softmax Probabilities: {probs.numpy().tolist()}")
+    logger.info(f"Max Probability (Confidence): {max_prob.item():.4f}")
+    logger.info(f"Predicted Index: {pred_idx.item()}")
+    
+    # Calculate energy score
+    energy = -torch.logsumexp(logits, dim=-1)
+    logger.info(f"Energy Score: {energy.item():.4f}")
+    
+    # OOD detection
+    is_ood = False
+    if method == 'energy':
+        is_ood = energy.item() > energy_threshold
+    elif method == 'msp':
+        is_ood = max_prob.item() < msp_threshold
+    elif method == 'combined':
+        is_ood = (energy.item() > energy_threshold) and (max_prob.item() < msp_threshold)
+    
+    logger.info(f"OOD Detection -> is_ood: {is_ood}")
+    if is_ood:
+        logger.info("Prediction marked as OUT-OF-DISTRIBUTION.")
+    else:
+        logger.info("Prediction marked as IN-DISTRIBUTION.")
+    
+    # Get intent label
+    predicted_intent = intent_classes[pred_idx.item()] if not is_ood else "unknown"
+    logger.info(f"Predicted Intent: {predicted_intent}")
+    logger.info("=============================================\n")
+
+    return {
+        "intent": predicted_intent,
+        "is_ood": is_ood,
+        "confidence": max_prob.item(),
+        "energy_score": energy.item()
+    }
+
+def initialize_models():
+    """Load both models on startup."""
+    global recommender_model_loaded
+    
+    # Load intent classification model
+    try:
+        load_intent_resources()
+        logger.info("Intent classification model loaded successfully!")
+    except Exception as e:
+        logger.error(f"Failed to load intent model: {str(e)}", exc_info=True)
+    
+    # Load book recommender model
+    logger.info("Loading recommender model...")
+    recommender_model_loaded = recommender.load_model("recommender_model")
+    if recommender_model_loaded:
+        logger.info("Book recommender model loaded successfully!")
+    else:
+        logger.error("Failed to load book recommender model.")
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """Endpoint to check if the API is running and models are loaded."""
+    global recommender_model_loaded
+    
+    intent_model_loaded = intent_model is not None and intent_tokenizer is not None
+    
+    return jsonify({
+        "status": "healthy" if (intent_model_loaded and recommender_model_loaded) else "partial",
+        "services": {
+            "intent_classification": "loaded" if intent_model_loaded else "not loaded",
+            "book_recommendations": "loaded" if recommender_model_loaded else "not loaded"
+        }
+    })
+
+@app.route('/api/analyze', methods=['POST'])
+def analyze():
+    """Endpoint to predict intent from text."""
+    # Check if request contains JSON
+    if not request.is_json:
+        return jsonify({"error": "Request must be JSON"}), 400
+    
+    # Get text from request
+    data = request.get_json()
+    if 'text' not in data:
+        return jsonify({"error": "Missing 'text' field in request"}), 400
+    
+    text = data['text']
+    
+    # Default to combined method unless specified
+    method = data.get('method', 'combined')
+    if method not in ['energy', 'msp', 'combined']:
+        return jsonify({"error": "Invalid method. Must be 'energy', 'msp', or 'combined'"}), 400
+    
+    # Make prediction
+    result = predict_intent_with_enhanced_ood(
+        text, 
+        intent_model, 
+        intent_tokenizer, 
+        intent_classes, 
+        intent_thresholds["energy_threshold"],
+        intent_thresholds["msp_threshold"],
+        method=method
+    )
+    
+    # Return prediction as JSON
+    return jsonify(result)
+
+@app.route('/api/recommend', methods=['POST'])
+def recommend():
+    """Endpoint to get book recommendations based on user query."""
+    global recommender_model_loaded
+
+    if not recommender_model_loaded:
+        return jsonify({
+            "error": "Model not loaded",
+            "message": "The recommendation model is not properly loaded."
+        }), 503
+
+    data = request.get_json()
+
+    if not data:
+        return jsonify({
+            "error": "Invalid request",
+            "message": "No JSON data provided."
+        }), 400
+
+    query = data.get('query')
+    top_n = data.get('top_n', 5)
+    include_description = data.get('include_description', True)
+
+    if not query:
+        return jsonify({
+            "error": "Missing parameter",
+            "message": "Query parameter is required."
+        }), 400
+
+    try:
+        # Get recommendations
+        recommendations = recommender.recommend_books(
+            user_query=query,
+            top_n=int(top_n),
+            include_description=bool(include_description)
+        )
+
+        # CLEAN recommendations to make it JSON serializable
+        def clean_np(obj):
+            if isinstance(obj, np.integer):
+                return int(obj)
+            elif isinstance(obj, np.floating):
+                return float(obj)
+            elif isinstance(obj, np.ndarray):
+                return obj.tolist()
+            elif isinstance(obj, dict):
+                return {k: clean_np(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [clean_np(i) for i in obj]
+            else:
+                return obj
+
+        recommendations_clean = clean_np(recommendations)
+
+        return jsonify({
+            "query": query,
+            "recommendations": recommendations_clean,
+            "count": len(recommendations_clean)
+        })
+
+    except Exception as e:
+        logger.error(f"Error in recommendation endpoint: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred while processing your request: {str(e)}"
+        }), 500
+
+
+@app.route('/api/stats', methods=['GET'])
+def get_stats():
+    """Endpoint to get statistics about the loaded dataset."""
+    global recommender, recommender_model_loaded
+    
+    if not recommender_model_loaded:
+        return jsonify({
+            "error": "Model not loaded",
+            "message": "The recommendation model is not properly loaded."
+        }), 503
+    
+    try:
+        stats = {
+            "total_books": len(recommender.df) if recommender.df is not None else 0,
+            "model_name": recommender.model_name,
+            "categories": list(recommender.df['Category'].value_counts().head(10).to_dict().keys()) 
+                         if recommender.df is not None and 'Category' in recommender.df.columns else []
+        }
+        
+        return jsonify(stats)
+        
+    except Exception as e:
+        logger.error(f"Error in stats endpoint: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred while retrieving stats: {str(e)}"
+        }), 500
+
+@app.route('/', methods=['GET'])
+def index():
+    """Root endpoint providing API information."""
+    return jsonify({
+        "status": "API is running",
+        "services": {
+            "intent_analysis": "Available at /api/analyze",
+            "book_recommendations": "Available at /api/recommend",
+            "statistics": "Available at /api/stats",
+            "health_check": "Available at /api/health"
+        },
+        "version": "1.0.0"
+    })
+
+if __name__ == '__main__':
+    # Initialize models when the app starts
+    initialize_models()
+    
+    # Set port from environment variable or default to 5000
+    port = int(os.environ.get('PORT', 5000))
+    
+    # For development use debug=True, for production use debug=False
+    app.run(host='0.0.0.0', port=port, debug=False)
+
+#curl -X POST http://localhost:5000/api/recommend \-H "Content-Type: application/json" \-d '{"query": "programming for begginers","top_n": 10,"include_description": true}'	

app3.py

@@ -0,0 +1,580 @@
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import torch
+import numpy as np
+import pickle
+import os
+import json
+import logging
+import csv
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from datetime import datetime
+
+# Download necessary NLTK resources
+nltk.download('stopwords', quiet=True)
+nltk.download('punkt', quiet=True)
+nltk.download('wordnet', quiet=True)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    handlers=[logging.FileHandler("combined_api.log"),
+                              logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)  # Enable Cross-Origin Resource Sharing
+
+# Global variables and constants
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+INTENT_MODEL_PATH = os.path.join(BASE_DIR, "model")
+RECOMMENDER_MODEL_PATH = os.path.join(BASE_DIR, "recommender_model")
+EVAL_CSV = "model_evaluation.csv"
+
+# Global model variables
+intent_model = None
+intent_tokenizer = None
+intent_classes = None
+intent_thresholds = None
+recommender = None
+recommender_model_loaded = False
+
+#################################################
+# Book Recommender System
+#################################################
+
+class BookRecommender:
+    def __init__(self, model_name='all-minilm-l6-v2'):
+        """Initialize the book recommender with specified model."""
+        self.model_name = model_name
+        self.model = None
+        self.book_embeddings = None
+        self.df = None
+        self.stop_words = set(stopwords.words('english'))
+        self.lemmatizer = WordNetLemmatizer()
+        logger.info(f"BookRecommender initialized with model: {model_name}")
+        
+    def preprocess_text(self, text):
+        """Advanced text preprocessing with stopword removal and lemmatization."""
+        if not isinstance(text, str):
+            return ""
+            
+        # Convert to lowercase and remove special characters
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', ' ', text)
+        
+        # Tokenize, remove stopwords, and lemmatize
+        tokens = nltk.word_tokenize(text)
+        tokens = [self.lemmatizer.lemmatize(word) for word in tokens if word not in self.stop_words]
+        
+        return ' '.join(tokens)
+
+    def load_model(self, folder_path=RECOMMENDER_MODEL_PATH):
+        """Load a previously saved model and embeddings for inference."""
+        try:
+            # Check if folder exists
+            if not os.path.exists(folder_path):
+                logger.error(f"Model folder {folder_path} does not exist.")
+                return False
+                
+            # Load configuration
+            config_path = os.path.join(folder_path, "config.pkl")
+            with open(config_path, 'rb') as f:
+                config = pickle.load(f)
+            self.model_name = config['model_name']
+            logger.info(f"Loaded configuration: model_name={self.model_name}")
+            
+            # Load the sentence transformer model
+            model_path = os.path.join(folder_path, "sentence_transformer")
+            self.model = SentenceTransformer(model_path)
+            logger.info(f"Model loaded from {model_path}")
+            
+            # Load book embeddings
+            embeddings_path = os.path.join(folder_path, "book_embeddings.pkl")
+            with open(embeddings_path, 'rb') as f:
+                self.book_embeddings = pickle.load(f)
+            logger.info(f"Embeddings loaded: {len(self.book_embeddings)} book vectors")
+            
+            # Load the DataFrame
+            df_path = os.path.join(folder_path, "books_data.pkl")
+            with open(df_path, 'rb') as f:
+                self.df = pickle.load(f)
+            logger.info(f"DataFrame loaded: {len(self.df)} books")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}", exc_info=True)
+            return False
+
+    def recommend_books(self, user_query, top_n=5, include_description=True):
+        """Recommend books based on user query."""
+        if self.model is None or self.book_embeddings is None or self.df is None:
+            logger.error("Model not initialized. Cannot make recommendations.")
+            return []
+            
+        logger.info(f"Finding books similar to: '{user_query}'")
+        
+        try:
+            # Preprocess the query the same way as the book text
+            processed_query = self.preprocess_text(user_query)
+            
+            # Encode user query
+            user_embedding = self.model.encode([processed_query])
+            
+            # Compute similarity between query and books
+            similarities = cosine_similarity(user_embedding, self.book_embeddings)[0]
+            
+            # Get top N most similar books
+            similar_books_idx = np.argsort(similarities)[-top_n:][::-1]
+            
+            recommendations = []
+            
+            for i, idx in enumerate(similar_books_idx):
+                book_data = {}
+                
+                # Extract book information
+                if 'Title' in self.df.columns:
+                    book_data['title'] = self.df.iloc[idx]['Title']
+                
+                if 'Authors' in self.df.columns:
+                    book_data['author'] = self.df.iloc[idx]['Authors']
+                
+                if 'Category' in self.df.columns:
+                    book_data['category'] = self.df.iloc[idx]['Category']
+                
+                if 'Publish Date (Year)' in self.df.columns:
+                    book_data['year'] = self.df.iloc[idx]['Publish Date (Year)']
+                    
+                if include_description and 'Description' in self.df.columns:
+                    # Truncate long descriptions
+                    description = self.df.iloc[idx]['Description']
+                    if len(description) > 200:
+                        description = description[:197] + "..."
+                    book_data['description'] = description
+                
+                # Add similarity score
+                book_data['relevance_score'] = float(similarities[idx])
+                book_data['rank'] = i + 1
+                
+                recommendations.append(book_data)
+            
+            logger.info(f"Successfully generated {len(recommendations)} recommendations")
+            return recommendations
+            
+        except Exception as e:
+            logger.error(f"Error generating recommendations: {str(e)}", exc_info=True)
+            return []
+
+#################################################
+# Intent Classification
+#################################################
+
+def setup_evaluation_csv():
+    """Set up the CSV file for tracking model performance"""
+    if not os.path.exists(EVAL_CSV):
+        with open(EVAL_CSV, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                'timestamp', 
+                'input_text', 
+                'predicted_intent', 
+                'is_ood', 
+                'confidence', 
+                'energy_score',
+                'detection_method'
+            ])
+        logger.info(f"Created evaluation CSV file: {EVAL_CSV}")
+
+def save_prediction_to_csv(input_text, result, method):
+    """Save prediction results to CSV for later analysis"""
+    with open(EVAL_CSV, 'a', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow([
+            datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            input_text,
+            result['intent'],
+            result['is_ood'],
+            result['confidence'],
+            result['energy_score'],
+            method
+        ])
+
+def load_ood_thresholds(model_path):
+    """Load the OOD thresholds from the model directory"""
+    threshold_path = os.path.join(model_path, "ood_thresholds.json")
+    
+    if os.path.exists(threshold_path):
+        with open(threshold_path, "r") as f:
+            return json.load(f)
+    else:
+        # Provide default thresholds if file not found
+        logger.warning(f"Threshold file not found at {threshold_path}. Using default values.")
+        return {
+            "energy_threshold": 0.0,  # Replace with your default value
+            "msp_threshold": 0.5      # Replace with your default value
+        }
+
+def load_intent_resources():
+    """Load model, tokenizer, intent classes, and thresholds for intent classification."""
+    global intent_model, intent_tokenizer, intent_classes, intent_thresholds
+    
+    logger.info(f"Loading intent resources from {INTENT_MODEL_PATH}...")
+    
+    try:
+        # Load model and tokenizer
+        intent_model = AutoModelForSequenceClassification.from_pretrained(INTENT_MODEL_PATH)
+        intent_tokenizer = AutoTokenizer.from_pretrained(INTENT_MODEL_PATH)
+        
+        # Load intent classes
+        intent_classes_path = os.path.join(INTENT_MODEL_PATH, "intent_classes.pkl")
+        if os.path.exists(intent_classes_path):
+            with open(intent_classes_path, "rb") as f:
+                intent_classes = pickle.load(f)
+        else:
+            raise FileNotFoundError(f"Intent classes file not found at {intent_classes_path}")
+        
+        # Load OOD thresholds
+        intent_thresholds = load_ood_thresholds(INTENT_MODEL_PATH)
+        
+        logger.info("Intent resources loaded successfully")
+        logger.info(f"Loaded {len(intent_classes)} intent classes")
+        logger.info(f"Thresholds: {intent_thresholds}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Failed to load intent resources: {str(e)}", exc_info=True)
+        return False
+
+def predict_intent_with_enhanced_ood(text, model, tokenizer, intent_classes, 
+                                    energy_threshold, msp_threshold, method='combined'):
+    """
+    Predict intent with enhanced out-of-distribution detection and detailed logging.
+    """
+    logger.info("\n========== INTENT PREDICTION DEBUG ==========")
+    logger.info(f"Input Text: {text}")
+    logger.info(f"Detection Method: {method}")
+    
+    # Tokenize input
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
+    
+    # Get model outputs
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+
+    logger.info(f"Logits: {logits.numpy().tolist()}")
+
+    # Get probabilities
+    probs = torch.nn.functional.softmax(logits, dim=-1)
+    max_prob, pred_idx = torch.max(probs, dim=-1)
+
+    logger.info(f"Softmax Probabilities: {probs.numpy().tolist()}")
+    logger.info(f"Max Probability (Confidence): {max_prob.item():.4f}")
+    logger.info(f"Predicted Index: {pred_idx.item()}")
+    
+    # Calculate energy score
+    energy = -torch.logsumexp(logits, dim=-1)
+    logger.info(f"Energy Score: {energy.item():.4f}")
+    
+    # OOD detection
+    is_ood = False
+    if method == 'energy':
+        is_ood = energy.item() > energy_threshold
+    elif method == 'msp':
+        is_ood = max_prob.item() < msp_threshold
+    elif method == 'combined':
+        is_ood = (energy.item() > energy_threshold) and (max_prob.item() < msp_threshold)
+    
+    logger.info(f"OOD Detection -> is_ood: {is_ood}")
+    if is_ood:
+        logger.info("Prediction marked as OUT-OF-DISTRIBUTION.")
+    else:
+        logger.info("Prediction marked as IN-DISTRIBUTION.")
+    
+    # Get intent label
+    predicted_intent = intent_classes[pred_idx.item()]
+    logger.info(f"Predicted Intent: {predicted_intent}")
+    logger.info("=============================================\n")
+
+    return {
+        "intent": predicted_intent,
+        "is_ood": is_ood,
+        "confidence": max_prob.item(),
+        "energy_score": energy.item(),
+        # Add all class probabilities for detailed analysis
+        "class_probabilities": {
+            intent_classes[i]: float(prob) 
+            for i, prob in enumerate(probs[0].numpy())
+        }
+    }
+
+#################################################
+# Server Initialization
+#################################################
+
+def initialize_models():
+    """Load all required models on startup."""
+    global recommender, recommender_model_loaded
+    
+    # Create evaluation CSV if it doesn't exist
+    setup_evaluation_csv()
+    
+    # Load intent classification model
+    intent_model_loaded = load_intent_resources()
+    if intent_model_loaded:
+        logger.info("Intent classification model loaded successfully!")
+    else:
+        logger.error("Failed to load intent model.")
+    
+    # Initialize book recommender
+    recommender = BookRecommender()
+    recommender_model_loaded = recommender.load_model()
+    if recommender_model_loaded:
+        logger.info("Book recommendation model loaded successfully!")
+    else:
+        logger.error("Failed to load book recommendation model.")
+    
+    return intent_model_loaded and recommender_model_loaded
+
+#################################################
+# API Routes
+#################################################
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """Endpoint to check if the API is running and models are loaded."""
+    intent_models_loaded = intent_model is not None and intent_tokenizer is not None
+    
+    return jsonify({
+        "status": "healthy" if (intent_models_loaded and recommender_model_loaded) else "partially_healthy" if (intent_models_loaded or recommender_model_loaded) else "unhealthy",
+        "intent_model_loaded": intent_models_loaded,
+        "recommender_model_loaded": recommender_model_loaded,
+        "available_endpoints": [
+            "/api/health", 
+            "/api/analyze", 
+            "/api/recommend",
+            "/api/stats",
+            "/api/download_eval_data"
+        ]
+    })
+
+#################################################
+# Intent Classification Routes
+#################################################
+
+@app.route('/api/analyze', methods=['POST'])
+def analyze():
+    """Endpoint to predict intent from text."""
+    # Check if request contains JSON
+    if not request.is_json:
+        return jsonify({"error": "Request must be JSON"}), 400
+    
+    # Get text from request
+    data = request.get_json()
+    if 'text' not in data:
+        return jsonify({"error": "Missing 'text' field in request"}), 400
+    
+    text = data['text']
+    
+    # Default to combined method unless specified
+    method = data.get('method', 'combined')
+    if method not in ['energy', 'msp', 'combined']:
+        return jsonify({"error": "Invalid method. Must be 'energy', 'msp', or 'combined'"}), 400
+    
+    # Make prediction
+    result = predict_intent_with_enhanced_ood(
+        text, 
+        intent_model, 
+        intent_tokenizer, 
+        intent_classes, 
+        intent_thresholds["energy_threshold"],
+        intent_thresholds["msp_threshold"],
+        method=method
+    )
+    
+    # Save result to CSV for evaluation
+    save_prediction_to_csv(text, result, method)
+    
+    # Return prediction as JSON
+    return jsonify(result)
+
+@app.route('/api/stats', methods=['GET'])
+def get_stats():
+    """Get statistics about model usage and predictions."""
+    try:
+        stats = {
+            "intent_model_info": {
+                "num_intent_classes": len(intent_classes) if intent_classes else 0,
+                "model_path": INTENT_MODEL_PATH,
+                "thresholds": intent_thresholds
+            },
+            "recommender_model_info": {
+                "model_name": recommender.model_name if recommender else None,
+                "num_books": len(recommender.df) if recommender and recommender.df is not None else 0
+            },
+            "usage": {}
+        }
+        
+        # Read CSV to generate statistics if it exists
+        if os.path.exists(EVAL_CSV):
+            with open(EVAL_CSV, 'r') as f:
+                reader = csv.DictReader(f)
+                rows = list(reader)
+                
+                stats["usage"] = {
+                    "total_queries": len(rows),
+                    "ood_count": sum(1 for row in rows if row["is_ood"] == "True"),
+                    "top_intents": {}
+                }
+                
+                # Count intents for statistical analysis
+                intent_counts = {}
+                for row in rows:
+                    intent = row["predicted_intent"]
+                    if intent not in intent_counts:
+                        intent_counts[intent] = 0
+                    intent_counts[intent] += 1
+                
+                # Get top 5 intents
+                top_intents = sorted(intent_counts.items(), key=lambda x: x[1], reverse=True)[:5]
+                stats["usage"]["top_intents"] = dict(top_intents)
+        
+        return jsonify(stats)
+        
+    except Exception as e:
+        logger.error(f"Error in stats endpoint: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred while retrieving stats: {str(e)}"
+        }), 500
+
+@app.route('/api/download_eval_data', methods=['GET'])
+def download_eval_data():
+    """Return the evaluation data as JSON for analysis"""
+    try:
+        if not os.path.exists(EVAL_CSV):
+            return jsonify({"error": "No evaluation data available yet"}), 404
+            
+        with open(EVAL_CSV, 'r') as f:
+            reader = csv.DictReader(f)
+            rows = list(reader)
+            
+        return jsonify({
+            "count": len(rows),
+            "data": rows
+        })
+        
+    except Exception as e:
+        logger.error(f"Error downloading evaluation data: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred: {str(e)}"
+        }), 500
+
+#################################################
+# Book Recommender Routes
+#################################################
+
+@app.route('/api/recommend', methods=['POST'])
+def recommend():
+    """Endpoint to get book recommendations based on user query."""
+    global recommender_model_loaded
+
+    if not recommender_model_loaded:
+        return jsonify({
+            "error": "Model not loaded",
+            "message": "The recommendation model is not properly loaded."
+        }), 503
+
+    data = request.get_json()
+
+    if not data:
+        return jsonify({
+            "error": "Invalid request",
+            "message": "No JSON data provided."
+        }), 400
+
+    query = data.get('query')
+    top_n = data.get('top_n', 5)
+    include_description = data.get('include_description', True)
+    threshold = data.get('threshold', 0.5)  # default threshold
+
+    if not query:
+        return jsonify({
+            "error": "Missing parameter",
+            "message": "Query parameter is required."
+        }), 400
+
+    try:
+        # Get recommendations
+        recommendations = recommender.recommend_books(
+            user_query=query,
+            top_n=int(top_n),
+            include_description=bool(include_description)
+        )
+
+        # Clean recommendations to make it JSON serializable
+        def clean_np(obj):
+            if isinstance(obj, np.integer):
+                return int(obj)
+            elif isinstance(obj, np.floating):
+                return float(obj)
+            elif isinstance(obj, np.ndarray):
+                return obj.tolist()
+            elif isinstance(obj, dict):
+                return {k: clean_np(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [clean_np(i) for i in obj]
+            else:
+                return obj
+
+        recommendations_clean = clean_np(recommendations)
+
+        # Split based on threshold
+        high_score = [rec for rec in recommendations_clean if rec['relevance_score'] >= threshold]
+        low_score = [rec for rec in recommendations_clean if rec['relevance_score'] < threshold]
+
+        return jsonify({
+            "query": query,
+            "threshold": threshold,
+            "high_recommendations": high_score,
+            "low_recommendations": low_score,
+            "total_count": len(recommendations_clean),
+            "high_count": len(high_score),
+            "low_count": len(low_score)
+        })
+
+    except Exception as e:
+        logger.error(f"Error in recommendation endpoint: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred while processing your request: {str(e)}"
+        }), 500
+
+#################################################
+# Main
+#################################################
+
+if __name__ == '__main__':  
+    # Initialize models when the app starts
+    models_loaded = initialize_models()   
+    
+    # Set port from environment variable or default to 5000
+    port = int(os.environ.get('PORT', 5000))   
+    
+    # For development use debug=True, for production use debug=False
+    app.run(host='0.0.0.0', port=port, debug=False, use_reloader=False)
+	
+	
+	
+#curl -X POST http://localhost:5000/api/analyze \-H "Content-Type: application/json" \-d '{"text": "cariin buku", "method": "combined"}'
+	
+#curl -X POST http://localhost:5000/api/recommend \-H "Content-Type: application/json" \-d '{"query": "programming for begginers","top_n": 10,"include_description": true}'		 
+	

app4.py

@@ -0,0 +1,580 @@
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import torch
+import numpy as np
+import pickle
+import os
+import json
+import logging
+import csv
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from datetime import datetime
+
+# Download necessary NLTK resources
+nltk.download('stopwords', quiet=True)
+nltk.download('punkt', quiet=True)
+nltk.download('wordnet', quiet=True)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    handlers=[logging.FileHandler("combined_api.log"),
+                              logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)  # Enable Cross-Origin Resource Sharing
+
+# Global variables and constants
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+INTENT_MODEL_PATH = os.path.join(BASE_DIR, "model")
+RECOMMENDER_MODEL_PATH = os.path.join(BASE_DIR, "recommender_model")
+EVAL_CSV = "model_evaluation.csv"
+
+# Global model variables
+intent_model = None
+intent_tokenizer = None
+intent_classes = None
+intent_thresholds = None
+recommender = None
+recommender_model_loaded = False
+
+#################################################
+# Book Recommender System
+#################################################
+
+class BookRecommender:
+    def __init__(self, model_name='all-minilm-l6-v2'):
+        """Initialize the book recommender with specified model."""
+        self.model_name = model_name
+        self.model = None
+        self.book_embeddings = None
+        self.df = None
+        self.stop_words = set(stopwords.words('english'))
+        self.lemmatizer = WordNetLemmatizer()
+        logger.info(f"BookRecommender initialized with model: {model_name}")
+        
+    def preprocess_text(self, text):
+        """Advanced text preprocessing with stopword removal and lemmatization."""
+        if not isinstance(text, str):
+            return ""
+            
+        # Convert to lowercase and remove special characters
+        text = text.lower()
+        text = re.sub(r'[^\w\s]', ' ', text)
+        
+        # Tokenize, remove stopwords, and lemmatize
+        tokens = nltk.word_tokenize(text)
+        tokens = [self.lemmatizer.lemmatize(word) for word in tokens if word not in self.stop_words]
+        
+        return ' '.join(tokens)
+
+    def load_model(self, folder_path=RECOMMENDER_MODEL_PATH):
+        """Load a previously saved model and embeddings for inference."""
+        try:
+            # Check if folder exists
+            if not os.path.exists(folder_path):
+                logger.error(f"Model folder {folder_path} does not exist.")
+                return False
+                
+            # Load configuration
+            config_path = os.path.join(folder_path, "config.pkl")
+            with open(config_path, 'rb') as f:
+                config = pickle.load(f)
+            self.model_name = config['model_name']
+            logger.info(f"Loaded configuration: model_name={self.model_name}")
+            
+            # Load the sentence transformer model
+            model_path = os.path.join(folder_path, "sentence_transformer")
+            self.model = SentenceTransformer(model_path)
+            logger.info(f"Model loaded from {model_path}")
+            
+            # Load book embeddings
+            embeddings_path = os.path.join(folder_path, "book_embeddings.pkl")
+            with open(embeddings_path, 'rb') as f:
+                self.book_embeddings = pickle.load(f)
+            logger.info(f"Embeddings loaded: {len(self.book_embeddings)} book vectors")
+            
+            # Load the DataFrame
+            df_path = os.path.join(folder_path, "books_data.pkl")
+            with open(df_path, 'rb') as f:
+                self.df = pickle.load(f)
+            logger.info(f"DataFrame loaded: {len(self.df)} books")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}", exc_info=True)
+            return False
+
+    def recommend_books(self, user_query, top_n=5, include_description=True):
+        """Recommend books based on user query."""
+        if self.model is None or self.book_embeddings is None or self.df is None:
+            logger.error("Model not initialized. Cannot make recommendations.")
+            return []
+            
+        logger.info(f"Finding books similar to: '{user_query}'")
+        
+        try:
+            # Preprocess the query the same way as the book text
+            processed_query = self.preprocess_text(user_query)
+            
+            # Encode user query
+            user_embedding = self.model.encode([processed_query])
+            
+            # Compute similarity between query and books
+            similarities = cosine_similarity(user_embedding, self.book_embeddings)[0]
+            
+            # Get top N most similar books
+            similar_books_idx = np.argsort(similarities)[-top_n:][::-1]
+            
+            recommendations = []
+            
+            for i, idx in enumerate(similar_books_idx):
+                book_data = {}
+                
+                # Extract book information
+                if 'Title' in self.df.columns:
+                    book_data['title'] = self.df.iloc[idx]['Title']
+                
+                if 'Authors' in self.df.columns:
+                    book_data['author'] = self.df.iloc[idx]['Authors']
+                
+                if 'Category' in self.df.columns:
+                    book_data['category'] = self.df.iloc[idx]['Category']
+                
+                if 'Publish Date (Year)' in self.df.columns:
+                    book_data['year'] = self.df.iloc[idx]['Publish Date (Year)']
+                    
+                if include_description and 'Description' in self.df.columns:
+                    # Truncate long descriptions
+                    description = self.df.iloc[idx]['Description']
+                    if len(description) > 200:
+                        description = description[:197] + "..."
+                    book_data['description'] = description
+                
+                # Add similarity score
+                book_data['relevance_score'] = float(similarities[idx])
+                book_data['rank'] = i + 1
+                
+                recommendations.append(book_data)
+            
+            logger.info(f"Successfully generated {len(recommendations)} recommendations")
+            return recommendations
+            
+        except Exception as e:
+            logger.error(f"Error generating recommendations: {str(e)}", exc_info=True)
+            return []
+
+#################################################
+# Intent Classification
+#################################################
+
+def setup_evaluation_csv():
+    """Set up the CSV file for tracking model performance"""
+    if not os.path.exists(EVAL_CSV):
+        with open(EVAL_CSV, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                'timestamp', 
+                'input_text', 
+                'predicted_intent', 
+                'is_ood', 
+                'confidence', 
+                'energy_score',
+                'detection_method'
+            ])
+        logger.info(f"Created evaluation CSV file: {EVAL_CSV}")
+
+def save_prediction_to_csv(input_text, result, method):
+    """Save prediction results to CSV for later analysis"""
+    with open(EVAL_CSV, 'a', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow([
+            datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            input_text,
+            result['intent'],
+            result['is_ood'],
+            result['confidence'],
+            result['energy_score'],
+            method
+        ])
+
+def load_ood_thresholds(model_path):
+    """Load the OOD thresholds from the model directory"""
+    threshold_path = os.path.join(model_path, "ood_thresholds.json")
+    
+    if os.path.exists(threshold_path):
+        with open(threshold_path, "r") as f:
+            return json.load(f)
+    else:
+        # Provide default thresholds if file not found
+        logger.warning(f"Threshold file not found at {threshold_path}. Using default values.")
+        return {
+            "energy_threshold": 0.0,  # Replace with your default value
+            "msp_threshold": 0.5      # Replace with your default value
+        }
+
+def load_intent_resources():
+    """Load model, tokenizer, intent classes, and thresholds for intent classification."""
+    global intent_model, intent_tokenizer, intent_classes, intent_thresholds
+    
+    logger.info(f"Loading intent resources from {INTENT_MODEL_PATH}...")
+    
+    try:
+        # Load model and tokenizer
+        intent_model = AutoModelForSequenceClassification.from_pretrained("ZEROTSUDIOS/Bipa-Classification")
+        intent_tokenizer = AutoTokenizer.from_pretrained("ZEROTSUDIOS/Bipa-Classification")
+        
+        # Load intent classes
+        intent_classes_path = os.path.join(INTENT_MODEL_PATH, "intent_classes.pkl")
+        if os.path.exists(intent_classes_path):
+            with open(intent_classes_path, "rb") as f:
+                intent_classes = pickle.load(f)
+        else:
+            raise FileNotFoundError(f"Intent classes file not found at {intent_classes_path}")
+        
+        # Load OOD thresholds
+        intent_thresholds = load_ood_thresholds(INTENT_MODEL_PATH)
+        
+        logger.info("Intent resources loaded successfully")
+        logger.info(f"Loaded {len(intent_classes)} intent classes")
+        logger.info(f"Thresholds: {intent_thresholds}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Failed to load intent resources: {str(e)}", exc_info=True)
+        return False
+
+def predict_intent_with_enhanced_ood(text, model, tokenizer, intent_classes, 
+                                    energy_threshold, msp_threshold, method='combined'):
+    """
+    Predict intent with enhanced out-of-distribution detection and detailed logging.
+    """
+    logger.info("\n========== INTENT PREDICTION DEBUG ==========")
+    logger.info(f"Input Text: {text}")
+    logger.info(f"Detection Method: {method}")
+    
+    # Tokenize input
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
+    
+    # Get model outputs
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+
+    logger.info(f"Logits: {logits.numpy().tolist()}")
+
+    # Get probabilities
+    probs = torch.nn.functional.softmax(logits, dim=-1)
+    max_prob, pred_idx = torch.max(probs, dim=-1)
+
+    logger.info(f"Softmax Probabilities: {probs.numpy().tolist()}")
+    logger.info(f"Max Probability (Confidence): {max_prob.item():.4f}")
+    logger.info(f"Predicted Index: {pred_idx.item()}")
+    
+    # Calculate energy score
+    energy = -torch.logsumexp(logits, dim=-1)
+    logger.info(f"Energy Score: {energy.item():.4f}")
+    
+    # OOD detection
+    is_ood = False
+    if method == 'energy':
+        is_ood = energy.item() > energy_threshold
+    elif method == 'msp':
+        is_ood = max_prob.item() < msp_threshold
+    elif method == 'combined':
+        is_ood = (energy.item() > energy_threshold) and (max_prob.item() < msp_threshold)
+    
+    logger.info(f"OOD Detection -> is_ood: {is_ood}")
+    if is_ood:
+        logger.info("Prediction marked as OUT-OF-DISTRIBUTION.")
+    else:
+        logger.info("Prediction marked as IN-DISTRIBUTION.")
+    
+    # Get intent label
+    predicted_intent = intent_classes[pred_idx.item()]
+    logger.info(f"Predicted Intent: {predicted_intent}")
+    logger.info("=============================================\n")
+
+    return {
+        "intent": predicted_intent,
+        "is_ood": is_ood,
+        "confidence": max_prob.item(),
+        "energy_score": energy.item(),
+        # Add all class probabilities for detailed analysis
+        "class_probabilities": {
+            intent_classes[i]: float(prob) 
+            for i, prob in enumerate(probs[0].numpy())
+        }
+    }
+
+#################################################
+# Server Initialization
+#################################################
+
+def initialize_models():
+    """Load all required models on startup."""
+    global recommender, recommender_model_loaded
+    
+    # Create evaluation CSV if it doesn't exist
+    setup_evaluation_csv()
+    
+    # Load intent classification model
+    intent_model_loaded = load_intent_resources()
+    if intent_model_loaded:
+        logger.info("Intent classification model loaded successfully!")
+    else:
+        logger.error("Failed to load intent model.")
+    
+    # Initialize book recommender
+    recommender = BookRecommender()
+    recommender_model_loaded = recommender.load_model()
+    if recommender_model_loaded:
+        logger.info("Book recommendation model loaded successfully!")
+    else:
+        logger.error("Failed to load book recommendation model.")
+    
+    return intent_model_loaded and recommender_model_loaded
+
+#################################################
+# API Routes
+#################################################
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """Endpoint to check if the API is running and models are loaded."""
+    intent_models_loaded = intent_model is not None and intent_tokenizer is not None
+    
+    return jsonify({
+        "status": "healthy" if (intent_models_loaded and recommender_model_loaded) else "partially_healthy" if (intent_models_loaded or recommender_model_loaded) else "unhealthy",
+        "intent_model_loaded": intent_models_loaded,
+        "recommender_model_loaded": recommender_model_loaded,
+        "available_endpoints": [
+            "/api/health", 
+            "/api/analyze", 
+            "/api/recommend",
+            "/api/stats",
+            "/api/download_eval_data"
+        ]
+    })
+
+#################################################
+# Intent Classification Routes
+#################################################
+
+@app.route('/api/analyze', methods=['POST'])
+def analyze():
+    """Endpoint to predict intent from text."""
+    # Check if request contains JSON
+    if not request.is_json:
+        return jsonify({"error": "Request must be JSON"}), 400
+    
+    # Get text from request
+    data = request.get_json()
+    if 'text' not in data:
+        return jsonify({"error": "Missing 'text' field in request"}), 400
+    
+    text = data['text']
+    
+    # Default to combined method unless specified
+    method = data.get('method', 'combined')
+    if method not in ['energy', 'msp', 'combined']:
+        return jsonify({"error": "Invalid method. Must be 'energy', 'msp', or 'combined'"}), 400
+    
+    # Make prediction
+    result = predict_intent_with_enhanced_ood(
+        text, 
+        intent_model, 
+        intent_tokenizer, 
+        intent_classes, 
+        intent_thresholds["energy_threshold"],
+        intent_thresholds["msp_threshold"],
+        method=method
+    )
+    
+    # Save result to CSV for evaluation
+    save_prediction_to_csv(text, result, method)
+    
+    # Return prediction as JSON
+    return jsonify(result)
+
+@app.route('/api/stats', methods=['GET'])
+def get_stats():
+    """Get statistics about model usage and predictions."""
+    try:
+        stats = {
+            "intent_model_info": {
+                "num_intent_classes": len(intent_classes) if intent_classes else 0,
+                "model_path": INTENT_MODEL_PATH,
+                "thresholds": intent_thresholds
+            },
+            "recommender_model_info": {
+                "model_name": recommender.model_name if recommender else None,
+                "num_books": len(recommender.df) if recommender and recommender.df is not None else 0
+            },
+            "usage": {}
+        }
+        
+        # Read CSV to generate statistics if it exists
+        if os.path.exists(EVAL_CSV):
+            with open(EVAL_CSV, 'r') as f:
+                reader = csv.DictReader(f)
+                rows = list(reader)
+                
+                stats["usage"] = {
+                    "total_queries": len(rows),
+                    "ood_count": sum(1 for row in rows if row["is_ood"] == "True"),
+                    "top_intents": {}
+                }
+                
+                # Count intents for statistical analysis
+                intent_counts = {}
+                for row in rows:
+                    intent = row["predicted_intent"]
+                    if intent not in intent_counts:
+                        intent_counts[intent] = 0
+                    intent_counts[intent] += 1
+                
+                # Get top 5 intents
+                top_intents = sorted(intent_counts.items(), key=lambda x: x[1], reverse=True)[:5]
+                stats["usage"]["top_intents"] = dict(top_intents)
+        
+        return jsonify(stats)
+        
+    except Exception as e:
+        logger.error(f"Error in stats endpoint: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred while retrieving stats: {str(e)}"
+        }), 500
+
+@app.route('/api/download_eval_data', methods=['GET'])
+def download_eval_data():
+    """Return the evaluation data as JSON for analysis"""
+    try:
+        if not os.path.exists(EVAL_CSV):
+            return jsonify({"error": "No evaluation data available yet"}), 404
+            
+        with open(EVAL_CSV, 'r') as f:
+            reader = csv.DictReader(f)
+            rows = list(reader)
+            
+        return jsonify({
+            "count": len(rows),
+            "data": rows
+        })
+        
+    except Exception as e:
+        logger.error(f"Error downloading evaluation data: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred: {str(e)}"
+        }), 500
+
+#################################################
+# Book Recommender Routes
+#################################################
+
+@app.route('/api/recommend', methods=['POST'])
+def recommend():
+    """Endpoint to get book recommendations based on user query."""
+    global recommender_model_loaded
+
+    if not recommender_model_loaded:
+        return jsonify({
+            "error": "Model not loaded",
+            "message": "The recommendation model is not properly loaded."
+        }), 503
+
+    data = request.get_json()
+
+    if not data:
+        return jsonify({
+            "error": "Invalid request",
+            "message": "No JSON data provided."
+        }), 400
+
+    query = data.get('query')
+    top_n = data.get('top_n', 5)
+    include_description = data.get('include_description', True)
+    threshold = data.get('threshold', 0.5)  # default threshold
+
+    if not query:
+        return jsonify({
+            "error": "Missing parameter",
+            "message": "Query parameter is required."
+        }), 400
+
+    try:
+        # Get recommendations
+        recommendations = recommender.recommend_books(
+            user_query=query,
+            top_n=int(top_n),
+            include_description=bool(include_description)
+        )
+
+        # Clean recommendations to make it JSON serializable
+        def clean_np(obj):
+            if isinstance(obj, np.integer):
+                return int(obj)
+            elif isinstance(obj, np.floating):
+                return float(obj)
+            elif isinstance(obj, np.ndarray):
+                return obj.tolist()
+            elif isinstance(obj, dict):
+                return {k: clean_np(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [clean_np(i) for i in obj]
+            else:
+                return obj
+
+        recommendations_clean = clean_np(recommendations)
+
+        # Split based on threshold
+        high_score = [rec for rec in recommendations_clean if rec['relevance_score'] >= threshold]
+        low_score = [rec for rec in recommendations_clean if rec['relevance_score'] < threshold]
+
+        return jsonify({
+            "query": query,
+            "threshold": threshold,
+            "high_recommendations": high_score,
+            "low_recommendations": low_score,
+            "total_count": len(recommendations_clean),
+            "high_count": len(high_score),
+            "low_count": len(low_score)
+        })
+
+    except Exception as e:
+        logger.error(f"Error in recommendation endpoint: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Processing error",
+            "message": f"An error occurred while processing your request: {str(e)}"
+        }), 500
+
+#################################################
+# Main
+#################################################
+
+if __name__ == '__main__':  
+    # Initialize models when the app starts
+    models_loaded = initialize_models()   
+    
+    # Set port from environment variable or default to 5000
+    port = int(os.environ.get('PORT', 5000))   
+    
+    # For development use debug=True, for production use debug=False
+    app.run(host='0.0.0.0', port=port, debug=False, use_reloader=False)
+	
+	
+	
+#curl -X POST http://localhost:5000/api/analyze \-H "Content-Type: application/json" \-d '{"text": "cariin buku", "method": "combined"}'
+	
+#curl -X POST http://localhost:5000/api/recommend \-H "Content-Type: application/json" \-d '{"query": "programming for begginers","top_n": 10,"include_description": true}'		 
+	

evaluate_model.py

@@ -0,0 +1,208 @@
+
+"""
+Intent Classification Model Evaluator
+
+This script analyzes the CSV data produced by the Flask app to generate
+evaluation metrics and visualizations.
+"""
+
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import argparse
+from datetime import datetime
+
+
+def load_evaluation_data(csv_path="model_evaluation.csv"):
+    """Load the CSV data and do basic preprocessing"""
+    if not os.path.exists(csv_path):
+        print(f"Error: File {csv_path} not found")
+        return None
+        
+    # Load the data
+    df = pd.read_csv(csv_path)
+    
+    # Convert string boolean to actual boolean
+	#df['is_ood'] = df['is_ood'].apply(lambda x: x.lower() == 'true')
+    df['is_ood'] = df['is_ood'].apply(lambda x: str(x).lower() == 'true')
+    
+    # Convert timestamp to datetime
+    df['timestamp'] = pd.to_datetime(df['timestamp'])
+    
+    print(f"Loaded {len(df)} evaluation records")
+    return df
+
+
+def generate_basic_stats(df):
+    """Generate basic statistics from the evaluation data"""
+    if df is None or len(df) == 0:
+        return "No data available for analysis"
+        
+    stats = {
+        "total_queries": len(df),
+        "unique_queries": df['input_text'].nunique(),
+        "in_distribution_count": (~df['is_ood']).sum(),
+        "out_of_distribution_count": df['is_ood'].sum(),
+        "ood_percentage": df['is_ood'].mean() * 100,
+        "avg_confidence": df['confidence'].mean(),
+        "avg_energy_score": df['energy_score'].mean(),
+        "top_intents": df['predicted_intent'].value_counts().head(10).to_dict()
+    }
+    
+    # Calculate metrics grouped by detection method
+    method_stats = df.groupby('detection_method').agg({
+        'is_ood': ['mean', 'count'],
+        'confidence': ['mean', 'std'],
+        'energy_score': ['mean', 'std']
+    })
+    
+    return stats, method_stats
+
+
+def plot_distributions(df, output_dir="evaluation_plots"):
+    """Create plots for analyzing the model performance"""
+    if df is None or len(df) == 0:
+        print("No data available for plotting")
+        return
+        
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    # Plot 1: Confidence Distribution
+    plt.figure(figsize=(10, 6))
+    plt.hist(df[~df['is_ood']]['confidence'], bins=20, alpha=0.7, label='In-Distribution')
+    plt.hist(df[df['is_ood']]['confidence'], bins=20, alpha=0.7, label='Out-of-Distribution')
+    plt.xlabel('Confidence Score')
+    plt.ylabel('Count')
+    plt.title('Confidence Score Distribution')
+    plt.legend()
+    plt.savefig(os.path.join(output_dir, f"{timestamp}_confidence_distribution.png"))
+    
+    # Plot 2: Energy Score Distribution
+    plt.figure(figsize=(10, 6))
+    plt.hist(df[~df['is_ood']]['energy_score'], bins=20, alpha=0.7, label='In-Distribution')
+    plt.hist(df[df['is_ood']]['energy_score'], bins=20, alpha=0.7, label='Out-of-Distribution')
+    plt.xlabel('Energy Score')
+    plt.ylabel('Count')
+    plt.title('Energy Score Distribution')
+    plt.legend()
+    plt.savefig(os.path.join(output_dir, f"{timestamp}_energy_distribution.png"))
+    
+    # Plot 3: Intent Distribution (Top 10)
+    intent_counts = df['predicted_intent'].value_counts().head(10)
+    plt.figure(figsize=(12, 6))
+    intent_counts.plot(kind='bar')
+    plt.xlabel('Intent')
+    plt.ylabel('Count')
+    plt.title('Top 10 Predicted Intents')
+    plt.xticks(rotation=45, ha='right')
+    plt.tight_layout()
+    plt.savefig(os.path.join(output_dir, f"{timestamp}_intent_distribution.png"))
+    
+    # Plot 4: OOD Detection Method Comparison
+    plt.figure(figsize=(10, 6))
+    method_ood = df.groupby('detection_method')['is_ood'].mean() * 100
+    method_ood.plot(kind='bar')
+    plt.xlabel('Detection Method')
+    plt.ylabel('OOD Percentage')
+    plt.title('OOD Detection Rate by Method')
+    plt.savefig(os.path.join(output_dir, f"{timestamp}_ood_by_method.png"))
+    
+    print(f"Plots saved to {output_dir} directory")
+
+
+def analyze_inputs(df):
+    """Analyze input texts for patterns"""
+    if df is None or len(df) == 0:
+        return "No data available for analysis"
+        
+    # Basic text statistics
+    df['text_length'] = df['input_text'].apply(len)
+    df['word_count'] = df['input_text'].apply(lambda x: len(x.split()))
+    
+    text_stats = {
+        "avg_text_length": df['text_length'].mean(),
+        "avg_word_count": df['word_count'].mean(),
+        "max_text_length": df['text_length'].max(),
+        "min_text_length": df['text_length'].min()
+    }
+    
+    # Analyze correlation between text length and predictions
+    length_vs_ood = df.groupby(pd.cut(df['text_length'], 10))['is_ood'].mean()
+    length_vs_confidence = df.groupby(pd.cut(df['text_length'], 10))['confidence'].mean()
+    
+    print("\nInput Text Analysis:")
+    print(f"Average text length: {text_stats['avg_text_length']:.1f} characters")
+    print(f"Average word count: {text_stats['avg_word_count']:.1f} words")
+    
+    return text_stats, length_vs_ood, length_vs_confidence
+
+
+def suggest_thresholds(df):
+    """Analyze the data to suggest optimal thresholds for OOD detection"""
+    if df is None or len(df) == 0 or len(df['is_ood'].unique()) < 2:
+        return "Insufficient data for threshold analysis - need both OOD and non-OOD examples"
+    
+    # Simple suggestion based on average values
+    suggested_energy = np.mean([
+        df[df['is_ood']]['energy_score'].mean(),
+        df[~df['is_ood']]['energy_score'].mean()
+    ])
+    
+    suggested_msp = np.mean([
+        df[df['is_ood']]['confidence'].mean(),
+        df[~df['is_ood']]['confidence'].mean()
+    ])
+    
+    print("\nThreshold Suggestions:")
+    print(f"Current data suggests an energy threshold around: {suggested_energy:.4f}")
+    print(f"Current data suggests an MSP threshold around: {suggested_msp:.4f}")
+    print("Note: These are rough estimates. For proper threshold tuning,")
+    print("you should use a dedicated validation set and ROC curve analysis.")
+    
+    return suggested_energy, suggested_msp
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze intent classification evaluation data")
+    parser.add_argument('--csv', default='model_evaluation.csv', help='Path to the evaluation CSV file')
+    parser.add_argument('--plots', default='evaluation_plots', help='Directory to save plots')
+    parser.add_argument('--no-plots', action='store_true', help='Skip generating plots')
+    args = parser.parse_args()
+    
+    print(f"Loading data from {args.csv}...")
+    df = load_evaluation_data(args.csv)
+    
+    if df is not None and len(df) > 0:
+        print("\n===== BASIC STATISTICS =====")
+        stats, method_stats = generate_basic_stats(df)
+        print(f"Total queries: {stats['total_queries']}")
+        print(f"In-distribution queries: {stats['in_distribution_count']} ({100-stats['ood_percentage']:.1f}%)")
+        print(f"Out-of-distribution queries: {stats['out_of_distribution_count']} ({stats['ood_percentage']:.1f}%)")
+        print(f"Average confidence score: {stats['avg_confidence']:.4f}")
+        print(f"Average energy score: {stats['avg_energy_score']:.4f}")
+        
+        print("\nTop predicted intents:")
+        for intent, count in list(stats['top_intents'].items())[:5]:
+            print(f"  - {intent}: {count}")
+            
+        print("\n===== DETECTION METHOD COMPARISON =====")
+        print(method_stats)
+        
+        # Analyze input texts
+        analyze_inputs(df)
+        
+        # Suggest threshold values
+        suggest_thresholds(df)
+        
+        # Generate plots if not disabled
+        if not args.no_plots:
+            plot_distributions(df, args.plots)
+            
+    print("\nAnalysis complete!")
+
+
+if __name__ == "__main__":
+    main()

hf.py

@@ -0,0 +1,18 @@
+from huggingface_hub import login, create_repo, upload_folder
+
+# 1. 🔐 Login using your HF token (get it from https://huggingface.co/settings/tokens)
+login("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")  # <--- ganti dengan token kamu
+
+# 2. 📁 Create repo on Hugging Face (if belum dibuat). Ganti nama repo sesuai keinginan.
+repo_name = "Bipa-Classification"  # bebas, asal unik di akunmu
+create_repo(repo_name, private=False)
+
+# 3. 🚀 Upload the model folder
+upload_folder(
+    folder_path="./model",              # this path is correct from your working dir
+    path_in_repo="",                    # upload everything into root of repo
+    repo_id="ZEROTSUDIOS/" + repo_name,  # <--- ganti your_username
+    repo_type="model"
+)
+
+print("✅ Upload completed!")

intent_api.log

@@ -0,0 +1,504 @@
+2025-05-10 20:51:10,272 - __main__ - INFO - Created evaluation CSV file: model_evaluation.csv
+2025-05-10 20:51:10,275 - __main__ - INFO - Loading intent resources from C:\xampp\htdocs\ChatbotPerpusBipa\py\model...
+2025-05-10 20:52:12,106 - __main__ - INFO - Intent resources loaded successfully
+2025-05-10 20:52:12,108 - __main__ - INFO - Loaded 9 intent classes
+2025-05-10 20:52:12,113 - __main__ - INFO - Thresholds: {'energy_threshold': -5.720269680023193, 'msp_threshold': 0.8734092712402344}
+2025-05-10 20:52:12,114 - __main__ - INFO - Intent classification model loaded successfully!
+2025-05-10 20:52:13,087 - werkzeug - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
+ * Running on all addresses (0.0.0.0)
+ * Running on http://127.0.0.1:5000
+ * Running on http://192.168.1.9:5000
+2025-05-10 20:52:13,088 - werkzeug - INFO - Press CTRL+C to quit
+2025-05-10 20:52:13,148 - werkzeug - INFO -  * Restarting with stat
+2025-05-10 20:52:43,569 - __main__ - INFO - Loading intent resources from C:\xampp\htdocs\ChatbotPerpusBipa\py\model...
+2025-05-10 20:53:35,798 - __main__ - INFO - Loading intent resources from C:\xampp\htdocs\ChatbotPerpusBipa\py\model...
+2025-05-10 20:53:38,986 - __main__ - INFO - Intent resources loaded successfully
+2025-05-10 20:53:38,986 - __main__ - INFO - Loaded 9 intent classes
+2025-05-10 20:53:38,986 - __main__ - INFO - Thresholds: {'energy_threshold': -5.720269680023193, 'msp_threshold': 0.8734092712402344}
+2025-05-10 20:53:38,986 - __main__ - INFO - Intent classification model loaded successfully!
+2025-05-10 20:53:39,220 - werkzeug - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
+ * Running on all addresses (0.0.0.0)
+ * Running on http://127.0.0.1:5000
+ * Running on http://192.168.1.9:5000
+2025-05-10 20:53:39,220 - werkzeug - INFO - Press CTRL+C to quit
+2025-05-10 20:53:39,236 - werkzeug - INFO -  * Restarting with stat
+2025-05-10 20:53:49,002 - __main__ - INFO - Loading intent resources from C:\xampp\htdocs\ChatbotPerpusBipa\py\model...
+2025-05-10 21:03:09,865 - __main__ - INFO - Loading intent resources from C:\xampp\htdocs\ChatbotPerpusBipa\py\model...
+2025-05-10 21:03:13,006 - __main__ - INFO - Intent resources loaded successfully
+2025-05-10 21:03:13,006 - __main__ - INFO - Loaded 9 intent classes
+2025-05-10 21:03:13,006 - __main__ - INFO - Thresholds: {'energy_threshold': -5.720269680023193, 'msp_threshold': 0.8734092712402344}
+2025-05-10 21:03:13,006 - __main__ - INFO - Intent classification model loaded successfully!
+2025-05-10 21:03:13,037 - werkzeug - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
+ * Running on all addresses (0.0.0.0)
+ * Running on http://127.0.0.1:5000
+ * Running on http://192.168.1.9:5000
+2025-05-10 21:03:13,037 - werkzeug - INFO - Press CTRL+C to quit
+2025-05-10 21:04:34,421 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:04:34,421 - __main__ - INFO - Input Text: hi
+2025-05-10 21:04:34,421 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:04:43,102 - __main__ - INFO - Logits: [[-1.3176556825637817, -1.1946855783462524, -0.858184278011322, -1.1091588735580444, -1.0160118341445923, 1.3968093395233154, 5.099667072296143, -1.0186958312988281, -0.7325793504714966]]
+2025-05-10 21:04:43,618 - __main__ - INFO - Softmax Probabilities: [[0.0015701063675805926, 0.0017755558947101235, 0.0024858498945832253, 0.0019340959843248129, 0.0021229088306427, 0.023703157901763916, 0.9614725708961487, 0.0021172184497117996, 0.0028185418341308832]]
+2025-05-10 21:04:43,633 - __main__ - INFO - Max Probability (Confidence): 0.9615
+2025-05-10 21:04:43,633 - __main__ - INFO - Predicted Index: 6
+2025-05-10 21:04:44,086 - __main__ - INFO - Energy Score: -5.1390
+2025-05-10 21:04:44,086 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:04:44,086 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:04:44,086 - __main__ - INFO - Predicted Intent: greeting
+2025-05-10 21:04:44,086 - __main__ - INFO - =============================================
+
+2025-05-10 21:04:44,086 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:04:44] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:10:56,497 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:10:56,498 - __main__ - INFO - Input Text: selamat pagi, saya inginn tau cara meminjam buku boleh? makasih
+2025-05-10 21:10:56,499 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:10:58,421 - __main__ - INFO - Logits: [[5.399814605712891, 0.087623231112957, -0.8307769298553467, -0.6626364588737488, -0.7578122615814209, 0.10144484788179398, -0.7953941226005554, -0.3702244460582733, -1.1888351440429688]]
+2025-05-10 21:10:58,423 - __main__ - INFO - Softmax Probabilities: [[0.9776320457458496, 0.0048208096995949745, 0.001924260170198977, 0.002276598708704114, 0.0020699123851954937, 0.0048879035748541355, 0.0019935655873268843, 0.0030498558189719915, 0.0013451204868033528]]
+2025-05-10 21:10:58,424 - __main__ - INFO - Max Probability (Confidence): 0.9776
+2025-05-10 21:10:58,427 - __main__ - INFO - Predicted Index: 0
+2025-05-10 21:10:58,430 - __main__ - INFO - Energy Score: -5.4224
+2025-05-10 21:10:58,432 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:10:58,437 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:10:58,440 - __main__ - INFO - Predicted Intent: cara_pinjam
+2025-05-10 21:10:58,442 - __main__ - INFO - =============================================
+
+2025-05-10 21:10:58,449 - test - ERROR - Exception on /api/analyze [POST]
+Traceback (most recent call last):
+  File "C:\Users\User\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\flask\app.py", line 1473, in wsgi_app
+    response = self.full_dispatch_request()
+  File "C:\Users\User\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\flask\app.py", line 882, in full_dispatch_request
+    rv = self.handle_user_exception(e)
+  File "C:\Users\User\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\flask_cors\extension.py", line 176, in wrapped_function
+    return cors_after_request(app.make_response(f(*args, **kwargs)))
+  File "C:\Users\User\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\flask\app.py", line 880, in full_dispatch_request
+    rv = self.dispatch_request()
+  File "C:\Users\User\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\flask\app.py", line 865, in dispatch_request
+    return self.ensure_sync(self.view_functions[rule.endpoint])(**view_args)  # type: ignore[no-any-return]
+  File "C:\xampp\htdocs\ChatbotPerpusBipa\py\test.py", line 234, in analyze
+    save_prediction_to_csv(text, result, method)
+  File "C:\xampp\htdocs\ChatbotPerpusBipa\py\test.py", line 52, in save_prediction_to_csv
+    with open(EVAL_CSV, 'a', newline='') as f:
+PermissionError: [Errno 13] Permission denied: 'model_evaluation.csv'
+2025-05-10 21:11:03,159 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:11:03] "POST /api/analyze HTTP/1.1" 500 -
+2025-05-10 21:11:30,805 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:11:30,806 - __main__ - INFO - Input Text: selamat pagi, saya inginn tau cara meminjam buku boleh? makasih
+2025-05-10 21:11:30,807 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:11:32,361 - __main__ - INFO - Logits: [[5.399814605712891, 0.087623231112957, -0.8307769298553467, -0.6626364588737488, -0.7578122615814209, 0.10144484788179398, -0.7953941226005554, -0.3702244460582733, -1.1888351440429688]]
+2025-05-10 21:11:32,365 - __main__ - INFO - Softmax Probabilities: [[0.9776320457458496, 0.0048208096995949745, 0.001924260170198977, 0.002276598708704114, 0.0020699123851954937, 0.0048879035748541355, 0.0019935655873268843, 0.0030498558189719915, 0.0013451204868033528]]
+2025-05-10 21:11:32,370 - __main__ - INFO - Max Probability (Confidence): 0.9776
+2025-05-10 21:11:32,373 - __main__ - INFO - Predicted Index: 0
+2025-05-10 21:11:32,379 - __main__ - INFO - Energy Score: -5.4224
+2025-05-10 21:11:32,387 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:11:32,390 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:11:32,393 - __main__ - INFO - Predicted Intent: cara_pinjam
+2025-05-10 21:11:32,397 - __main__ - INFO - =============================================
+
+2025-05-10 21:11:32,412 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:11:32] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:20:06,316 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:20:06,316 - __main__ - INFO - Input Text: hello nigga
+2025-05-10 21:20:06,316 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:20:07,046 - __main__ - INFO - Logits: [[-1.059308648109436, -1.1259849071502686, -0.7732775807380676, -1.1819493770599365, -1.1710785627365112, 1.4521418809890747, 5.11907958984375, -1.0589956045150757, -1.0377000570297241]]
+2025-05-10 21:20:07,046 - __main__ - INFO - Softmax Probabilities: [[0.0019936026073992252, 0.0018650107085704803, 0.0026537510566413403, 0.0017635031836107373, 0.001782778650522232, 0.02456674538552761, 0.9613432288169861, 0.001994226360693574, 0.002037149854004383]]
+2025-05-10 21:20:07,046 - __main__ - INFO - Max Probability (Confidence): 0.9613
+2025-05-10 21:20:07,046 - __main__ - INFO - Predicted Index: 6
+2025-05-10 21:20:07,046 - __main__ - INFO - Energy Score: -5.1585
+2025-05-10 21:20:07,046 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:20:07,046 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:20:07,062 - __main__ - INFO - Predicted Intent: greeting
+2025-05-10 21:20:07,062 - __main__ - INFO - =============================================
+
+2025-05-10 21:20:07,062 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:20:07] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:20:12,732 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:20:12,732 - __main__ - INFO - Input Text: jawir
+2025-05-10 21:20:12,732 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:20:13,156 - __main__ - INFO - Logits: [[-1.6685775518417358, -1.273998737335205, 2.2453248500823975, 3.137083053588867, -0.7543082237243652, -1.4736096858978271, 2.1617510318756104, -1.6372283697128296, -1.1733094453811646]]
+2025-05-10 21:20:13,156 - __main__ - INFO - Softmax Probabilities: [[0.004400658421218395, 0.006529518403112888, 0.2204468846321106, 0.537761390209198, 0.010979431681334972, 0.0053479960188269615, 0.20277215540409088, 0.004540801048278809, 0.007221210282295942]]
+2025-05-10 21:20:13,156 - __main__ - INFO - Max Probability (Confidence): 0.5378
+2025-05-10 21:20:13,156 - __main__ - INFO - Predicted Index: 3
+2025-05-10 21:20:13,156 - __main__ - INFO - Energy Score: -3.7574
+2025-05-10 21:20:13,156 - __main__ - INFO - OOD Detection -> is_ood: True
+2025-05-10 21:20:13,156 - __main__ - INFO - Prediction marked as OUT-OF-DISTRIBUTION.
+2025-05-10 21:20:13,156 - __main__ - INFO - Predicted Intent: unknown
+2025-05-10 21:20:13,171 - __main__ - INFO - =============================================
+
+2025-05-10 21:20:13,249 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:20:13] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:23:46,590 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:23:46,592 - __main__ - INFO - Input Text: aku pergi
+2025-05-10 21:23:46,593 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:23:49,019 - __main__ - INFO - Logits: [[-0.9422286748886108, -0.8617181777954102, -1.3514978885650635, 0.15106375515460968, -1.3091967105865479, 4.960031509399414, 0.3698965013027191, -0.15400801599025726, -0.9507330656051636]]
+2025-05-10 21:23:49,113 - __main__ - INFO - Softmax Probabilities: [[0.0026371763087809086, 0.002858277875930071, 0.0017514426726847887, 0.007869554683566093, 0.0018271200824528933, 0.9648464918136597, 0.009794626384973526, 0.005800415761768818, 0.0026148436591029167]]
+2025-05-10 21:23:49,128 - __main__ - INFO - Max Probability (Confidence): 0.9648
+2025-05-10 21:23:49,128 - __main__ - INFO - Predicted Index: 5
+2025-05-10 21:23:49,128 - __main__ - INFO - Energy Score: -4.9958
+2025-05-10 21:23:49,144 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:23:49,144 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:23:49,144 - __main__ - INFO - Predicted Intent: goodbye
+2025-05-10 21:23:49,159 - __main__ - INFO - =============================================
+
+2025-05-10 21:23:49,175 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:23:49] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:23:55,322 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:23:55,322 - __main__ - INFO - Input Text: ga mau
+2025-05-10 21:23:55,322 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:23:55,676 - __main__ - INFO - Logits: [[-0.9056248068809509, -0.013884905725717545, 0.027644459158182144, 5.6327104568481445, -0.8719817996025085, -0.5354712009429932, -0.7891335487365723, -0.8269177079200745, -0.5340971946716309]]
+2025-05-10 21:23:55,676 - __main__ - INFO - Softmax Probabilities: [[0.0014219597214832902, 0.003468685783445835, 0.0036157723516225815, 0.9827662706375122, 0.0014706128276884556, 0.0020589372143149376, 0.0015976395225152373, 0.0015384004218503833, 0.002061767503619194]]
+2025-05-10 21:23:55,676 - __main__ - INFO - Max Probability (Confidence): 0.9828
+2025-05-10 21:23:55,676 - __main__ - INFO - Predicted Index: 3
+2025-05-10 21:23:55,676 - __main__ - INFO - Energy Score: -5.6501
+2025-05-10 21:23:55,676 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:23:55,676 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:23:55,676 - __main__ - INFO - Predicted Intent: denied
+2025-05-10 21:23:55,676 - __main__ - INFO - =============================================
+
+2025-05-10 21:23:55,676 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:23:55] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:24:02,159 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:24:02,159 - __main__ - INFO - Input Text: cariin buku :)
+2025-05-10 21:24:02,159 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:24:02,801 - __main__ - INFO - Logits: [[-0.4540617763996124, 5.4417572021484375, -0.9955655336380005, -0.5665326714515686, 0.22001151740550995, -0.4966876804828644, -0.975710391998291, -0.5621989965438843, -1.544423222541809]]
+2025-05-10 21:24:02,817 - __main__ - INFO - Softmax Probabilities: [[0.002697325311601162, 0.9805168509483337, 0.0015695001929998398, 0.002410393673926592, 0.005292730871587992, 0.002584765199571848, 0.001600974122993648, 0.002420861506834626, 0.0009065577760338783]]
+2025-05-10 21:24:02,817 - __main__ - INFO - Max Probability (Confidence): 0.9805
+2025-05-10 21:24:02,817 - __main__ - INFO - Predicted Index: 1
+2025-05-10 21:24:02,817 - __main__ - INFO - Energy Score: -5.4614
+2025-05-10 21:24:02,817 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:24:02,817 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:24:02,817 - __main__ - INFO - Predicted Intent: cari_buku
+2025-05-10 21:24:02,817 - __main__ - INFO - =============================================
+
+2025-05-10 21:24:02,832 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:24:02] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:24:08,582 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:24:08] "POST /api/recommend HTTP/1.1" 404 -
+2025-05-10 21:24:24,640 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:24:24,655 - __main__ - INFO - Input Text: engga
+2025-05-10 21:24:24,655 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:24:24,971 - __main__ - INFO - Logits: [[-1.0960450172424316, -0.19882100820541382, 1.0277540683746338, 5.673742771148682, -0.9991940855979919, -0.5354593992233276, -1.1831791400909424, -0.9452515244483948, -0.6324564814567566]]
+2025-05-10 21:24:24,971 - __main__ - INFO - Softmax Probabilities: [[0.0011242710752412677, 0.002757594920694828, 0.009402111172676086, 0.9793829321861267, 0.0012386050075292587, 0.001969383331015706, 0.0010304549941793084, 0.0013072536094114184, 0.0017873314209282398]]
+2025-05-10 21:24:24,971 - __main__ - INFO - Max Probability (Confidence): 0.9794
+2025-05-10 21:24:24,971 - __main__ - INFO - Predicted Index: 3
+2025-05-10 21:24:24,986 - __main__ - INFO - Energy Score: -5.6946
+2025-05-10 21:24:24,986 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:24:24,986 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:24:24,986 - __main__ - INFO - Predicted Intent: denied
+2025-05-10 21:24:24,986 - __main__ - INFO - =============================================
+
+2025-05-10 21:24:25,002 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:24:25] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:24:35,923 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:24:35,923 - __main__ - INFO - Input Text: kali ini gimana cara jadi anggota
+2025-05-10 21:24:35,939 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:24:36,611 - __main__ - INFO - Logits: [[0.7106897234916687, -1.2784496545791626, -1.4926022291183472, -0.25034889578819275, -1.2656588554382324, -0.8868540525436401, 0.061691418290138245, -1.14139723777771, 5.139155864715576]]
+2025-05-10 21:24:36,627 - __main__ - INFO - Softmax Probabilities: [[0.011566980741918087, 0.0015825150767341256, 0.0012774458155035973, 0.0044243172742426395, 0.0016028864774852991, 0.0023410762660205364, 0.0060445452108979225, 0.0018149681854993105, 0.969345211982727]]
+2025-05-10 21:24:36,627 - __main__ - INFO - Max Probability (Confidence): 0.9693
+2025-05-10 21:24:36,627 - __main__ - INFO - Predicted Index: 8
+2025-05-10 21:24:36,627 - __main__ - INFO - Energy Score: -5.1703
+2025-05-10 21:24:36,627 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:24:36,627 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:24:36,627 - __main__ - INFO - Predicted Intent: keanggotaan
+2025-05-10 21:24:36,643 - __main__ - INFO - =============================================
+
+2025-05-10 21:24:36,643 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:24:36] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:24:40,108 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:24:40,108 - __main__ - INFO - Input Text: apakah gw anggota
+2025-05-10 21:24:40,108 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:24:40,612 - __main__ - INFO - Logits: [[-1.2273778915405273, -1.939422369003296, -1.204856276512146, -0.7936017513275146, -0.8146175742149353, -0.17088937759399414, 1.614134669303894, -1.2518943548202515, 4.8576788902282715]]
+2025-05-10 21:24:40,613 - __main__ - INFO - Softmax Probabilities: [[0.002146817045286298, 0.0010533147724345326, 0.002195715205743909, 0.0033126971684396267, 0.003243803745135665, 0.006174789741635323, 0.036800041794776917, 0.002094824332743883, 0.9429781436920166]]
+2025-05-10 21:24:40,672 - __main__ - INFO - Max Probability (Confidence): 0.9430
+2025-05-10 21:24:40,672 - __main__ - INFO - Predicted Index: 8
+2025-05-10 21:24:40,672 - __main__ - INFO - Energy Score: -4.9164
+2025-05-10 21:24:40,672 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:24:40,672 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:24:40,672 - __main__ - INFO - Predicted Intent: keanggotaan
+2025-05-10 21:24:40,672 - __main__ - INFO - =============================================
+
+2025-05-10 21:24:40,687 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:24:40] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:28:41,246 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:28:41,246 - __main__ - INFO - Input Text: apa iyah?
+2025-05-10 21:28:41,262 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:28:41,778 - __main__ - INFO - Logits: [[-0.7390039563179016, -2.113006353378296, 3.0566437244415283, 3.1234726905822754, -1.570651650428772, -1.8655962944030762, 1.214770793914795, -1.274828314781189, -0.047212935984134674]]
+2025-05-10 21:28:41,778 - __main__ - INFO - Softmax Probabilities: [[0.009639445692300797, 0.0024396663065999746, 0.42902329564094543, 0.45867419242858887, 0.004196353256702423, 0.0031244901474565268, 0.06800887733697891, 0.005640873685479164, 0.01925276406109333]]
+2025-05-10 21:28:41,778 - __main__ - INFO - Max Probability (Confidence): 0.4587
+2025-05-10 21:28:41,794 - __main__ - INFO - Predicted Index: 3
+2025-05-10 21:28:41,794 - __main__ - INFO - Energy Score: -3.9029
+2025-05-10 21:28:41,794 - __main__ - INFO - OOD Detection -> is_ood: True
+2025-05-10 21:28:41,794 - __main__ - INFO - Prediction marked as OUT-OF-DISTRIBUTION.
+2025-05-10 21:28:41,794 - __main__ - INFO - Predicted Intent: unknown
+2025-05-10 21:28:41,794 - __main__ - INFO - =============================================
+
+2025-05-10 21:28:41,794 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:28:41] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:28:50,002 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:28:50,006 - __main__ - INFO - Input Text: yaudah deh iya
+2025-05-10 21:28:50,010 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:28:50,508 - __main__ - INFO - Logits: [[-0.8829267621040344, -1.275931477546692, 5.552294731140137, 0.9029282331466675, -0.8707864880561829, -0.06326564401388168, -1.2235711812973022, -1.3446561098098755, -1.2907097339630127]]
+2025-05-10 21:28:50,509 - __main__ - INFO - Softmax Probabilities: [[0.0015714645851403475, 0.001060779090039432, 0.9796836376190186, 0.009373282082378864, 0.0015906589105725288, 0.003566801082342863, 0.0011178012937307358, 0.0009903260506689548, 0.0010452179703861475]]
+2025-05-10 21:28:50,514 - __main__ - INFO - Max Probability (Confidence): 0.9797
+2025-05-10 21:28:50,514 - __main__ - INFO - Predicted Index: 2
+2025-05-10 21:28:50,514 - __main__ - INFO - Energy Score: -5.5728
+2025-05-10 21:28:50,514 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:28:50,514 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:28:50,514 - __main__ - INFO - Predicted Intent: confirm
+2025-05-10 21:28:50,514 - __main__ - INFO - =============================================
+
+2025-05-10 21:28:50,534 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:28:50] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:28:58,131 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:28:58,131 - __main__ - INFO - Input Text: apa bedanya cari buku sama pinjam buku
+2025-05-10 21:28:58,131 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:28:58,711 - __main__ - INFO - Logits: [[5.502951622009277, 1.039902925491333, -1.1021047830581665, -0.5494447946548462, -0.45617687702178955, -0.8856024742126465, -1.2792505025863647, -0.7736234068870544, -0.5327207446098328]]
+2025-05-10 21:28:58,711 - __main__ - INFO - Softmax Probabilities: [[0.9757035970687866, 0.01124709565192461, 0.0013206215808168054, 0.002295068232342601, 0.0025194245390594006, 0.0016398499719798565, 0.0011062286794185638, 0.0018341547111049294, 0.00233377399854362]]
+2025-05-10 21:28:58,711 - __main__ - INFO - Max Probability (Confidence): 0.9757
+2025-05-10 21:28:58,711 - __main__ - INFO - Predicted Index: 0
+2025-05-10 21:28:58,711 - __main__ - INFO - Energy Score: -5.5275
+2025-05-10 21:28:58,711 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:28:58,727 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:28:58,727 - __main__ - INFO - Predicted Intent: cara_pinjam
+2025-05-10 21:28:58,727 - __main__ - INFO - =============================================
+
+2025-05-10 21:28:58,885 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:28:58] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:37:55,693 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:38:01,389 - __main__ - INFO - Input Text: apa yang anda tahu tentang benda benda di perpustakaan?
+2025-05-10 21:38:01,391 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:38:04,009 - __main__ - INFO - Logits: [[-0.7697362899780273, 1.3467382192611694, -1.27949059009552, -1.299091100692749, 5.202969551086426, -1.3397959470748901, -0.9824981689453125, -0.4959643483161926, -0.7740484476089478]]
+2025-05-10 21:38:04,025 - __main__ - INFO - Softmax Probabilities: [[0.002458558650687337, 0.020410509780049324, 0.0014767165994271636, 0.0014480534009635448, 0.9651476740837097, 0.0013902944047003984, 0.0019873722922056913, 0.003232794813811779, 0.0024479799903929234]]
+2025-05-10 21:38:04,041 - __main__ - INFO - Max Probability (Confidence): 0.9651
+2025-05-10 21:38:04,041 - __main__ - INFO - Predicted Index: 4
+2025-05-10 21:38:04,056 - __main__ - INFO - Energy Score: -5.2384
+2025-05-10 21:38:04,056 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:38:04,056 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:38:04,056 - __main__ - INFO - Predicted Intent: fasilitas
+2025-05-10 21:38:04,056 - __main__ - INFO - =============================================
+
+2025-05-10 21:38:04,119 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:38:04] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:38:14,947 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:38:14,947 - __main__ - INFO - Input Text: apa yang anda tahu tentang benda benda yang ada di perpustakaan?
+2025-05-10 21:38:14,947 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:38:15,790 - __main__ - INFO - Logits: [[-0.7680988907814026, 1.2449392080307007, -1.196992039680481, -1.266596794128418, 5.14818000793457, -1.350130319595337, -1.160045862197876, -0.40871661901474, -0.8047224283218384]]
+2025-05-10 21:38:15,790 - __main__ - INFO - Softmax Probabilities: [[0.002601428423076868, 0.019474362954497337, 0.0016941269859671593, 0.0015802178531885147, 0.9652040600776672, 0.001453579985536635, 0.0017578894039615989, 0.003726400900632143, 0.002507878467440605]]
+2025-05-10 21:38:15,790 - __main__ - INFO - Max Probability (Confidence): 0.9652
+2025-05-10 21:38:15,806 - __main__ - INFO - Predicted Index: 4
+2025-05-10 21:38:15,806 - __main__ - INFO - Energy Score: -5.1836
+2025-05-10 21:38:15,806 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:38:15,806 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:38:15,806 - __main__ - INFO - Predicted Intent: fasilitas
+2025-05-10 21:38:15,806 - __main__ - INFO - =============================================
+
+2025-05-10 21:38:15,821 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:38:15] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:38:26,471 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:38:26,475 - __main__ - INFO - Input Text: apa yang anda tahu tentang fasility yang ada di perpustakaan?
+2025-05-10 21:38:26,477 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:38:27,385 - __main__ - INFO - Logits: [[-1.6402337551116943, 0.28838950395584106, -1.0334101915359497, -1.377264380455017, 5.436436653137207, -1.3821498155593872, -1.1186164617538452, -0.2397802472114563, -0.14053963124752045]]
+2025-05-10 21:38:27,399 - __main__ - INFO - Softmax Probabilities: [[0.0008288080571219325, 0.005702228285372257, 0.0015205274103209376, 0.0010781027376651764, 0.9813252687454224, 0.0010728489141911268, 0.0013963347300887108, 0.00336250732652843, 0.003713324898853898]]
+2025-05-10 21:38:27,414 - __main__ - INFO - Max Probability (Confidence): 0.9813
+2025-05-10 21:38:27,414 - __main__ - INFO - Predicted Index: 4
+2025-05-10 21:38:27,414 - __main__ - INFO - Energy Score: -5.4553
+2025-05-10 21:38:27,414 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:38:27,414 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:38:27,414 - __main__ - INFO - Predicted Intent: fasilitas
+2025-05-10 21:38:27,414 - __main__ - INFO - =============================================
+
+2025-05-10 21:38:27,414 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:38:27] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:38:40,887 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:38:40,888 - __main__ - INFO - Input Text: apa yang anda tahu tentang fasilitas yang ada di perpustakaan?
+2025-05-10 21:38:40,891 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:38:41,756 - __main__ - INFO - Logits: [[-1.6494208574295044, 0.12875649333000183, -0.980239748954773, -1.2830331325531006, 5.473063945770264, -1.3103773593902588, -0.9920451045036316, -0.4207743704319, -0.007997849956154823]]
+2025-05-10 21:38:41,756 - __main__ - INFO - Softmax Probabilities: [[0.0007925480604171753, 0.004691137932240963, 0.00154755893163383, 0.0011432621395215392, 0.9823843240737915, 0.0011124236043542624, 0.0015293973265215755, 0.002707820851355791, 0.0040915366262197495]]
+2025-05-10 21:38:41,756 - __main__ - INFO - Max Probability (Confidence): 0.9824
+2025-05-10 21:38:41,756 - __main__ - INFO - Predicted Index: 4
+2025-05-10 21:38:41,756 - __main__ - INFO - Energy Score: -5.4908
+2025-05-10 21:38:41,756 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:38:41,772 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:38:41,855 - __main__ - INFO - Predicted Intent: fasilitas
+2025-05-10 21:38:41,855 - __main__ - INFO - =============================================
+
+2025-05-10 21:38:41,868 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:38:41] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:38:51,135 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:38:51,135 - __main__ - INFO - Input Text: fasilitas yang ada di perpustakaan?
+2025-05-10 21:38:51,135 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:38:51,684 - __main__ - INFO - Logits: [[-1.697698712348938, -0.4591014087200165, -0.9102374315261841, -1.1577955484390259, 5.437514305114746, -1.2155272960662842, -0.505920946598053, -0.38150474429130554, -0.2966429889202118]]
+2025-05-10 21:38:51,684 - __main__ - INFO - Softmax Probabilities: [[0.0007834106218069792, 0.00270336982794106, 0.0017217874992638826, 0.0013442077906802297, 0.9834970235824585, 0.00126880151219666, 0.0025797162670642138, 0.0029214955866336823, 0.0031802428420633078]]
+2025-05-10 21:38:51,699 - __main__ - INFO - Max Probability (Confidence): 0.9835
+2025-05-10 21:38:51,699 - __main__ - INFO - Predicted Index: 4
+2025-05-10 21:38:51,699 - __main__ - INFO - Energy Score: -5.4542
+2025-05-10 21:38:51,699 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:38:51,699 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:38:51,699 - __main__ - INFO - Predicted Intent: fasilitas
+2025-05-10 21:38:51,699 - __main__ - INFO - =============================================
+
+2025-05-10 21:38:51,715 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:38:51] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:38:57,269 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:38:57,273 - __main__ - INFO - Input Text: fasilitas?
+2025-05-10 21:38:57,277 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:38:57,554 - __main__ - INFO - Logits: [[-2.5640785694122314, -1.0151931047439575, -0.9696947932243347, -1.25716233253479, 3.5866546630859375, -0.20148932933807373, 2.6498327255249023, -0.7469539642333984, -0.534983217716217]]
+2025-05-10 21:38:57,554 - __main__ - INFO - Softmax Probabilities: [[0.0014459670055657625, 0.0068050408735871315, 0.007121811155229807, 0.005342504940927029, 0.6782468557357788, 0.01535386499017477, 0.26578542590141296, 0.008898678235709667, 0.010999760590493679]]
+2025-05-10 21:38:57,554 - __main__ - INFO - Max Probability (Confidence): 0.6782
+2025-05-10 21:38:57,554 - __main__ - INFO - Predicted Index: 4
+2025-05-10 21:38:57,570 - __main__ - INFO - Energy Score: -3.9749
+2025-05-10 21:38:57,570 - __main__ - INFO - OOD Detection -> is_ood: True
+2025-05-10 21:38:57,570 - __main__ - INFO - Prediction marked as OUT-OF-DISTRIBUTION.
+2025-05-10 21:38:57,570 - __main__ - INFO - Predicted Intent: unknown
+2025-05-10 21:38:57,586 - __main__ - INFO - =============================================
+
+2025-05-10 21:38:57,586 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:38:57] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:57:53,426 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:57:53,426 - __main__ - INFO - Input Text: apa yang anda tahu tentang benda benda yang ada di perpustakaan?
+2025-05-10 21:57:53,426 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:57:54,536 - __main__ - INFO - Logits: [[-0.7680988907814026, 1.2449392080307007, -1.196992039680481, -1.266596794128418, 5.14818000793457, -1.350130319595337, -1.160045862197876, -0.40871661901474, -0.8047224283218384]]
+2025-05-10 21:57:54,536 - __main__ - INFO - Softmax Probabilities: [[0.002601428423076868, 0.019474362954497337, 0.0016941269859671593, 0.0015802178531885147, 0.9652040600776672, 0.001453579985536635, 0.0017578894039615989, 0.003726400900632143, 0.002507878467440605]]
+2025-05-10 21:57:54,536 - __main__ - INFO - Max Probability (Confidence): 0.9652
+2025-05-10 21:57:54,536 - __main__ - INFO - Predicted Index: 4
+2025-05-10 21:57:54,536 - __main__ - INFO - Energy Score: -5.1836
+2025-05-10 21:57:54,551 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:57:54,551 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:57:54,567 - __main__ - INFO - Predicted Intent: fasilitas
+2025-05-10 21:57:54,598 - __main__ - INFO - =============================================
+
+2025-05-10 21:57:54,676 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:57:54] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:58:09,650 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:58:09,650 - __main__ - INFO - Input Text: selamat pagi dan selamat malam dan selamat siang
+2025-05-10 21:58:09,650 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:58:10,353 - __main__ - INFO - Logits: [[-1.015725016593933, -1.7672958374023438, -0.09375888109207153, -0.000339341553626582, -0.7917280793190002, 0.4557315409183502, 3.838515281677246, -0.13580496609210968, -1.4231810569763184]]
+2025-05-10 21:58:10,353 - __main__ - INFO - Softmax Probabilities: [[0.006958352401852608, 0.003281734185293317, 0.017494892701506615, 0.01920803263783455, 0.00870536733418703, 0.030307628214359283, 0.8926397562026978, 0.016774550080299377, 0.0046296752989292145]]
+2025-05-10 21:58:10,353 - __main__ - INFO - Max Probability (Confidence): 0.8926
+2025-05-10 21:58:10,353 - __main__ - INFO - Predicted Index: 6
+2025-05-10 21:58:10,368 - __main__ - INFO - Energy Score: -3.9521
+2025-05-10 21:58:10,368 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:58:10,368 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:58:10,368 - __main__ - INFO - Predicted Intent: greeting
+2025-05-10 21:58:10,368 - __main__ - INFO - =============================================
+
+2025-05-10 21:58:10,368 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:58:10] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:58:16,363 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:58:16,363 - __main__ - INFO - Input Text: lo jawa
+2025-05-10 21:58:16,363 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:58:16,774 - __main__ - INFO - Logits: [[-1.2190250158309937, -1.6057887077331543, 2.1177775859832764, 3.414398670196533, -1.2115315198898315, -1.0860720872879028, 1.689135193824768, -2.435594320297241, -0.16704648733139038]]
+2025-05-10 21:58:16,775 - __main__ - INFO - Softmax Probabilities: [[0.006397695280611515, 0.004345645196735859, 0.17996107041835785, 0.6581031084060669, 0.0064458162523806095, 0.007307425606995821, 0.11722534894943237, 0.001895284280180931, 0.01831859163939953]]
+2025-05-10 21:58:16,802 - __main__ - INFO - Max Probability (Confidence): 0.6581
+2025-05-10 21:58:16,802 - __main__ - INFO - Predicted Index: 3
+2025-05-10 21:58:16,818 - __main__ - INFO - Energy Score: -3.8328
+2025-05-10 21:58:16,818 - __main__ - INFO - OOD Detection -> is_ood: True
+2025-05-10 21:58:16,818 - __main__ - INFO - Prediction marked as OUT-OF-DISTRIBUTION.
+2025-05-10 21:58:16,818 - __main__ - INFO - Predicted Intent: unknown
+2025-05-10 21:58:16,834 - __main__ - INFO - =============================================
+
+2025-05-10 21:58:16,849 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:58:16] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:58:29,883 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:58:29,883 - __main__ - INFO - Input Text: Assalamualaikum wr wb
+2025-05-10 21:58:29,883 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:58:32,791 - __main__ - INFO - Logits: [[-1.131690263748169, -1.5006943941116333, -0.6151072978973389, -1.1938962936401367, -1.1617226600646973, 1.5072420835494995, 5.034933567047119, -1.0742135047912598, -0.8630368709564209]]
+2025-05-10 21:58:33,003 - __main__ - INFO - Softmax Probabilities: [[0.0020071538165211678, 0.0013877918245270848, 0.0033645734656602144, 0.0018861013231799006, 0.0019477707101032138, 0.028096651658415794, 0.956558346748352, 0.002125898841768503, 0.0026257631834596395]]
+2025-05-10 21:58:33,034 - __main__ - INFO - Max Probability (Confidence): 0.9566
+2025-05-10 21:58:33,034 - __main__ - INFO - Predicted Index: 6
+2025-05-10 21:58:33,034 - __main__ - INFO - Energy Score: -5.0793
+2025-05-10 21:58:33,034 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:58:33,034 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:58:33,034 - __main__ - INFO - Predicted Intent: greeting
+2025-05-10 21:58:33,049 - __main__ - INFO - =============================================
+
+2025-05-10 21:58:33,113 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:58:33] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:58:40,238 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:58:40,238 - __main__ - INFO - Input Text: ass
+2025-05-10 21:58:40,238 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:58:40,584 - __main__ - INFO - Logits: [[-1.3392796516418457, -1.524475336074829, 0.16145886480808258, -0.7817472815513611, -1.299397349357605, 1.4473503828048706, 5.0309271812438965, -1.4974311590194702, -0.9901137948036194]]
+2025-05-10 21:58:40,584 - __main__ - INFO - Softmax Probabilities: [[0.0016345757758244872, 0.0013582368846982718, 0.007331073749810457, 0.002854553982615471, 0.0017010837327688932, 0.026523033156991005, 0.9548842906951904, 0.0013954705791547894, 0.0023176397662609816]]
+2025-05-10 21:58:40,584 - __main__ - INFO - Max Probability (Confidence): 0.9549
+2025-05-10 21:58:40,584 - __main__ - INFO - Predicted Index: 6
+2025-05-10 21:58:40,584 - __main__ - INFO - Energy Score: -5.0771
+2025-05-10 21:58:40,599 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:58:40,631 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:58:40,631 - __main__ - INFO - Predicted Intent: greeting
+2025-05-10 21:58:40,631 - __main__ - INFO - =============================================
+
+2025-05-10 21:58:40,646 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:58:40] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:59:07,034 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:59:07,034 - __main__ - INFO - Input Text: gausah kocak besok aja bye
+2025-05-10 21:59:07,034 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:59:07,812 - __main__ - INFO - Logits: [[-0.6060627102851868, -0.5750446915626526, -1.0750855207443237, 0.9511569738388062, -1.388703465461731, 4.919146537780762, -0.24468335509300232, -0.4451393187046051, -0.9716767072677612]]
+2025-05-10 21:59:07,812 - __main__ - INFO - Softmax Probabilities: [[0.003815301228314638, 0.003935500048100948, 0.002386903390288353, 0.01810593344271183, 0.001744345179758966, 0.9574074745178223, 0.005476133432239294, 0.004481433890759945, 0.0026469440199434757]]
+2025-05-10 21:59:07,828 - __main__ - INFO - Max Probability (Confidence): 0.9574
+2025-05-10 21:59:07,828 - __main__ - INFO - Predicted Index: 5
+2025-05-10 21:59:07,828 - __main__ - INFO - Energy Score: -4.9627
+2025-05-10 21:59:07,828 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:59:07,828 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:59:07,828 - __main__ - INFO - Predicted Intent: goodbye
+2025-05-10 21:59:07,828 - __main__ - INFO - =============================================
+
+2025-05-10 21:59:07,843 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:59:07] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:59:11,113 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:59:11,113 - __main__ - INFO - Input Text: gausah
+2025-05-10 21:59:11,113 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:59:11,479 - __main__ - INFO - Logits: [[-1.1790672540664673, -0.19112896919250488, 0.6465687155723572, 5.715721130371094, -0.954384982585907, -0.07604362815618515, -1.0976141691207886, -1.0053229331970215, -0.6094058752059937]]
+2025-05-10 21:59:11,480 - __main__ - INFO - Softmax Probabilities: [[0.0009947115322574973, 0.0026714885607361794, 0.006173915695399046, 0.9818962812423706, 0.0012453041272237897, 0.0029973271302878857, 0.0010791246313601732, 0.0011834590695798397, 0.0017583195585757494]]
+2025-05-10 21:59:11,484 - __main__ - INFO - Max Probability (Confidence): 0.9819
+2025-05-10 21:59:11,484 - __main__ - INFO - Predicted Index: 3
+2025-05-10 21:59:11,484 - __main__ - INFO - Energy Score: -5.7340
+2025-05-10 21:59:11,484 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:59:11,484 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:59:11,484 - __main__ - INFO - Predicted Intent: denied
+2025-05-10 21:59:11,484 - __main__ - INFO - =============================================
+
+2025-05-10 21:59:11,533 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:59:11] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:59:20,905 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:59:20,905 - __main__ - INFO - Input Text: aku datang besok
+2025-05-10 21:59:20,905 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:59:21,327 - __main__ - INFO - Logits: [[-0.8137130737304688, -0.8092074394226074, -1.8744394779205322, 0.2625807821750641, -1.8174302577972412, 4.685948371887207, 0.7935030460357666, 0.8845048546791077, -1.1589834690093994]]
+2025-05-10 21:59:21,327 - __main__ - INFO - Softmax Probabilities: [[0.0038252437952905893, 0.00384251750074327, 0.0013243157882243395, 0.011222448199987411, 0.0014020069502294064, 0.935689389705658, 0.019083769991993904, 0.02090189978480339, 0.002708383370190859]]
+2025-05-10 21:59:21,327 - __main__ - INFO - Max Probability (Confidence): 0.9357
+2025-05-10 21:59:21,327 - __main__ - INFO - Predicted Index: 5
+2025-05-10 21:59:21,327 - __main__ - INFO - Energy Score: -4.7524
+2025-05-10 21:59:21,327 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 21:59:21,327 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 21:59:21,327 - __main__ - INFO - Predicted Intent: goodbye
+2025-05-10 21:59:21,343 - __main__ - INFO - =============================================
+
+2025-05-10 21:59:21,343 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:59:21] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 21:59:28,988 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 21:59:28,988 - __main__ - INFO - Input Text: aku akan tiba besok pagi
+2025-05-10 21:59:28,993 - __main__ - INFO - Detection Method: combined
+2025-05-10 21:59:29,531 - __main__ - INFO - Logits: [[-1.0576566457748413, -0.4939669370651245, -1.9942526817321777, 0.07859884947538376, -1.6343517303466797, 3.7366526126861572, 0.27028337121009827, 2.3993427753448486, -1.3766415119171143]]
+2025-05-10 21:59:29,531 - __main__ - INFO - Softmax Probabilities: [[0.00610245019197464, 0.01072288304567337, 0.0023919143714010715, 0.019009629264473915, 0.0034280631225556135, 0.7373034358024597, 0.02302614599466324, 0.193579763174057, 0.004435788374394178]]
+2025-05-10 21:59:29,531 - __main__ - INFO - Max Probability (Confidence): 0.7373
+2025-05-10 21:59:29,531 - __main__ - INFO - Predicted Index: 5
+2025-05-10 21:59:29,531 - __main__ - INFO - Energy Score: -4.0414
+2025-05-10 21:59:29,547 - __main__ - INFO - OOD Detection -> is_ood: True
+2025-05-10 21:59:29,547 - __main__ - INFO - Prediction marked as OUT-OF-DISTRIBUTION.
+2025-05-10 21:59:29,547 - __main__ - INFO - Predicted Intent: unknown
+2025-05-10 21:59:29,547 - __main__ - INFO - =============================================
+
+2025-05-10 21:59:29,563 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 21:59:29] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 22:02:08,601 - __main__ - INFO - 
+========== INTENT PREDICTION DEBUG ==========
+2025-05-10 22:02:08,601 - __main__ - INFO - Input Text: cariin buku bang
+2025-05-10 22:02:08,601 - __main__ - INFO - Detection Method: combined
+2025-05-10 22:02:09,038 - __main__ - INFO - Logits: [[-0.49238744378089905, 5.4453630447387695, -1.1035208702087402, -0.4974009394645691, 0.0320424884557724, -0.42038029432296753, -0.6259087324142456, -0.6300820112228394, -1.6206642389297485]]
+2025-05-10 22:02:09,038 - __main__ - INFO - Softmax Probabilities: [[0.0025876371655613184, 0.9809244871139526, 0.0014044019626453519, 0.0025746964383870363, 0.00437180045992136, 0.0027808379381895065, 0.002264204667881131, 0.002254775259643793, 0.00083733448991552]]
+2025-05-10 22:02:09,038 - __main__ - INFO - Max Probability (Confidence): 0.9809
+2025-05-10 22:02:09,038 - __main__ - INFO - Predicted Index: 1
+2025-05-10 22:02:09,053 - __main__ - INFO - Energy Score: -5.4646
+2025-05-10 22:02:09,053 - __main__ - INFO - OOD Detection -> is_ood: False
+2025-05-10 22:02:09,053 - __main__ - INFO - Prediction marked as IN-DISTRIBUTION.
+2025-05-10 22:02:09,053 - __main__ - INFO - Predicted Intent: cari_buku
+2025-05-10 22:02:09,053 - __main__ - INFO - =============================================
+
+2025-05-10 22:02:09,069 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 22:02:09] "POST /api/analyze HTTP/1.1" 200 -
+2025-05-10 22:02:12,836 - werkzeug - INFO - 127.0.0.1 - - [10/May/2025 22:02:12] "POST /api/recommend HTTP/1.1" 404 -

model/classification_report.csv

@@ -0,0 +1,14 @@
+,precision,recall,f1-score,support
+cara_pinjam,0.984,1.0,0.992,179.0
+cari_buku,0.989,0.983,0.986,180.0
+confirm,0.975,0.975,0.975,120.0
+denied,0.986,0.98,0.983,147.0
+fasilitas,0.989,0.983,0.986,178.0
+goodbye,0.993,0.978,0.985,136.0
+greeting,0.944,0.992,0.967,118.0
+jam_layanan,0.994,1.0,0.997,178.0
+keanggotaan,0.994,0.994,0.994,179.0
+peraturan,1.0,0.971,0.985,174.0
+accuracy,0.986,0.986,0.986,0.986
+macro avg,0.985,0.986,0.985,1589.0
+weighted avg,0.986,0.986,0.986,1589.0

model/classification_report.json

@@ -0,0 +1,75 @@
+{
+    "0": {
+        "precision": 0.9944444444444445,
+        "recall": 1.0,
+        "f1-score": 0.9972144846796658,
+        "support": 179.0
+    },
+    "1": {
+        "precision": 0.9888888888888889,
+        "recall": 0.9888888888888889,
+        "f1-score": 0.9888888888888889,
+        "support": 180.0
+    },
+    "2": {
+        "precision": 0.975,
+        "recall": 0.975,
+        "f1-score": 0.975,
+        "support": 120.0
+    },
+    "3": {
+        "precision": 0.9863013698630136,
+        "recall": 0.9795918367346939,
+        "f1-score": 0.9829351535836177,
+        "support": 147.0
+    },
+    "4": {
+        "precision": 0.9943181818181818,
+        "recall": 0.9831460674157303,
+        "f1-score": 0.9887005649717514,
+        "support": 178.0
+    },
+    "5": {
+        "precision": 0.9925373134328358,
+        "recall": 0.9779411764705882,
+        "f1-score": 0.9851851851851852,
+        "support": 136.0
+    },
+    "6": {
+        "precision": 0.9435483870967742,
+        "recall": 0.9915254237288136,
+        "f1-score": 0.9669421487603306,
+        "support": 118.0
+    },
+    "7": {
+        "precision": 0.994413407821229,
+        "recall": 1.0,
+        "f1-score": 0.9971988795518207,
+        "support": 178.0
+    },
+    "8": {
+        "precision": 0.9944444444444445,
+        "recall": 1.0,
+        "f1-score": 0.9972144846796658,
+        "support": 179.0
+    },
+    "9": {
+        "precision": 1.0,
+        "recall": 0.9770114942528736,
+        "f1-score": 0.9883720930232558,
+        "support": 174.0
+    },
+    "accuracy": 0.9880427942101951,
+    "macro avg": {
+        "precision": 0.9863896437809814,
+        "recall": 0.9873104887491589,
+        "f1-score": 0.9867651883324182,
+        "support": 1589.0
+    },
+    "weighted avg": {
+        "precision": 0.9882412962498892,
+        "recall": 0.9880427942101951,
+        "f1-score": 0.988071401599911,
+        "support": 1589.0
+    }
+}

model/config.json

@@ -0,0 +1,51 @@
+{
+  "architectures": [
+    "XLMRobertaForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2",
+    "3": "LABEL_3",
+    "4": "LABEL_4",
+    "5": "LABEL_5",
+    "6": "LABEL_6",
+    "7": "LABEL_7",
+    "8": "LABEL_8",
+    "9": "LABEL_9"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2,
+    "LABEL_3": 3,
+    "LABEL_4": 4,
+    "LABEL_5": 5,
+    "LABEL_6": 6,
+    "LABEL_7": 7,
+    "LABEL_8": 8,
+    "LABEL_9": 9
+  },
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "float32",
+  "transformers_version": "4.52.4",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

model/intent_classes.pkl

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

model/label_encoder.pkl

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

model/ood_thresholds.json

@@ -0,0 +1,4 @@
+{
+    "energy_threshold": -6.981417655944824,
+    "msp_threshold": 0.8888697624206543
+}

model/sentencepiece.bpe.model

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

model/special_tokens_map.json

@@ -0,0 +1,15 @@
+{
+  "bos_token": "<s>",
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "unk_token": "<unk>"
+}

model/test_results/test_run_20250702_143737/classification_report.json

@@ -0,0 +1,75 @@
+{
+    "cara_pinjam": {
+        "precision": 0.9534883720930233,
+        "recall": 1.0,
+        "f1-score": 0.9761904761904762,
+        "support": 41.0
+    },
+    "cari_buku": {
+        "precision": 1.0,
+        "recall": 1.0,
+        "f1-score": 1.0,
+        "support": 41.0
+    },
+    "confirm": {
+        "precision": 0.9714285714285714,
+        "recall": 0.8292682926829268,
+        "f1-score": 0.8947368421052632,
+        "support": 41.0
+    },
+    "denied": {
+        "precision": 0.9069767441860465,
+        "recall": 0.9512195121951219,
+        "f1-score": 0.9285714285714286,
+        "support": 41.0
+    },
+    "fasilitas": {
+        "precision": 1.0,
+        "recall": 1.0,
+        "f1-score": 1.0,
+        "support": 41.0
+    },
+    "goodbye": {
+        "precision": 0.9473684210526315,
+        "recall": 0.8780487804878049,
+        "f1-score": 0.9113924050632911,
+        "support": 41.0
+    },
+    "greeting": {
+        "precision": 0.8604651162790697,
+        "recall": 0.9024390243902439,
+        "f1-score": 0.8809523809523809,
+        "support": 41.0
+    },
+    "jam_layanan": {
+        "precision": 0.9318181818181818,
+        "recall": 1.0,
+        "f1-score": 0.9647058823529412,
+        "support": 41.0
+    },
+    "keanggotaan": {
+        "precision": 1.0,
+        "recall": 1.0,
+        "f1-score": 1.0,
+        "support": 41.0
+    },
+    "peraturan": {
+        "precision": 1.0,
+        "recall": 1.0,
+        "f1-score": 1.0,
+        "support": 41.0
+    },
+    "accuracy": 0.9560975609756097,
+    "macro avg": {
+        "precision": 0.9571545406857525,
+        "recall": 0.9560975609756097,
+        "f1-score": 0.9556549415235782,
+        "support": 410.0
+    },
+    "weighted avg": {
+        "precision": 0.9571545406857526,
+        "recall": 0.9560975609756097,
+        "f1-score": 0.955654941523578,
+        "support": 410.0
+    }
+}

model/test_results/test_run_20250702_143737/confidence_analysis.json

@@ -0,0 +1,13 @@
+{
+    "mean_confidence": 0.9509811997413635,
+    "std_confidence": 0.06421167403459549,
+    "min_confidence": 0.48898056149482727,
+    "max_confidence": 0.9849911332130432,
+    "median_confidence": 0.9713054299354553,
+    "q25_confidence": 0.9562950134277344,
+    "q75_confidence": 0.979069173336029,
+    "mean_confidence_correct": 0.9571561217308044,
+    "mean_confidence_incorrect": 0.816504180431366,
+    "std_confidence_correct": 0.048875272274017334,
+    "std_confidence_incorrect": 0.15158796310424805
+}