feat: added logging

Dockerfile

@@ -6,13 +6,15 @@ ENV PATH="/home/user/.local/bin:$PATH"
 
 WORKDIR /app
 
+# Create logs directory
+RUN mkdir -p /app/logs/running_logs && chown user:user /app/logs/running_logs
+
 COPY --chown=user ./requirements.txt requirements.txt
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
-COPY --chown=user . /app
-
-# Install DVC if needed (uncomment if using DVC in container)
+# Install DVC
 RUN pip install --no-cache-dir dvc
 
-CMD ["dvc","repro"]
-# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+COPY --chown=user . /app
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

components/model_ingestion.py

@@ -1,14 +1,22 @@
 from transformers import RobertaTokenizerFast, RobertaForSequenceClassification
-from utils.commons import HUGGINGFACE_MODEL_PATH, MODEL_SAVE_PATH
+from utils.commons import HUGGINGFACE_MODEL_PATH, MODEL_SAVE_PATH, setup_logging
 import os
 
+logger = setup_logging("model_ingestion.log")
+
 class ModelIngestor:
     @staticmethod
     def download_model():
         """Download and save the model"""
-        if not os.path.exists(MODEL_SAVE_PATH):
-            os.makedirs(MODEL_SAVE_PATH)
-            
-        RobertaTokenizerFast.from_pretrained(HUGGINGFACE_MODEL_PATH).save_pretrained(MODEL_SAVE_PATH)
-        RobertaForSequenceClassification.from_pretrained(HUGGINGFACE_MODEL_PATH).save_pretrained(MODEL_SAVE_PATH)
-        print(f"Model saved to {MODEL_SAVE_PATH}")
+        try:
+            if not os.path.exists(MODEL_SAVE_PATH):
+                os.makedirs(MODEL_SAVE_PATH)
+                logger.info(f"Created directory: {MODEL_SAVE_PATH}")
+
+            logger.info("Downloading tokenizer and model...")
+            RobertaTokenizerFast.from_pretrained(HUGGINGFACE_MODEL_PATH).save_pretrained(MODEL_SAVE_PATH)
+            RobertaForSequenceClassification.from_pretrained(HUGGINGFACE_MODEL_PATH).save_pretrained(MODEL_SAVE_PATH)
+            logger.info(f"Model and tokenizer saved to {MODEL_SAVE_PATH}")
+        except Exception as e:
+            logger.error(f"Error downloading model: {e}")
+            raise

components/model_loader.py

@@ -1,5 +1,7 @@
 from transformers import RobertaTokenizerFast, RobertaForSequenceClassification
-from utils.commons import MODEL_SAVE_PATH
+from utils.commons import MODEL_SAVE_PATH, setup_logging
+
+logger = setup_logging("model_loader.log")
 
 class ModelLoader:
     def __init__(self):
@@ -8,6 +10,12 @@ class ModelLoader:
         
     def load_model(self):
         """Load model from local path"""
-        self.tokenizer = RobertaTokenizerFast.from_pretrained(MODEL_SAVE_PATH)
-        self.model = RobertaForSequenceClassification.from_pretrained(MODEL_SAVE_PATH)
-        return self.tokenizer, self.model
+        try:
+            logger.info("Loading tokenizer and model...")
+            self.tokenizer = RobertaTokenizerFast.from_pretrained(MODEL_SAVE_PATH)
+            self.model = RobertaForSequenceClassification.from_pretrained(MODEL_SAVE_PATH)
+            logger.info("Tokenizer and model loaded successfully.")
+            return self.tokenizer, self.model
+        except Exception as e:
+            logger.error(f"Error loading model: {e}")
+            raise

components/pipeline_preparer.py

@@ -1,11 +1,21 @@
 from transformers import TextClassificationPipeline
+from utils.commons import setup_logging
+
+logger = setup_logging("pipeline_preparer.log")
 
 class PipelinePreparer:
     @staticmethod
     def prepare_pipeline(tokenizer, model):
         """Create text classification pipeline"""
-        return TextClassificationPipeline(
-            tokenizer=tokenizer,
-            model=model,
-            return_all_scores=True
-        )
+        try:
+            logger.info("Preparing text classification pipeline...")
+            pipeline = TextClassificationPipeline(
+                tokenizer=tokenizer,
+                model=model,
+                return_all_scores=True
+            )
+            logger.info("Pipeline prepared successfully.")
+            return pipeline
+        except Exception as e:
+            logger.error(f"Error preparing pipeline: {e}")
+            raise

components/predictor.py

@@ -1,12 +1,22 @@
+from utils.commons import setup_logging
+
+logger = setup_logging("predictor.log")
+
 class Predictor:
     def __init__(self, pipeline):
         self.pipeline = pipeline
         
     def predict(self, text):
         """Make prediction"""
-        preds_list = self.pipeline(text)
-        best_pred = max(preds_list[0], key=lambda x: x["score"])
-        return {
-            "predicted_intent": best_pred["label"],
-            "confidence": best_pred["score"]
-        }
+        try:
+            logger.info(f"Making prediction for text: {text}")
+            preds_list = self.pipeline(text)
+            best_pred = max(preds_list[0], key=lambda x: x["score"])
+            logger.info(f"Prediction successful: {best_pred}")
+            return {
+                "predicted_intent": best_pred["label"],
+                "confidence": best_pred["score"]
+            }
+        except Exception as e:
+            logger.error(f"Error during prediction: {e}")
+            raise

main.py

@@ -3,8 +3,11 @@ from pydantic import BaseModel
 from components.model_loader import ModelLoader
 from components.pipeline_preparer import PipelinePreparer
 from components.predictor import Predictor
+from utils.commons import setup_logging
 import uvicorn
 
+logger = setup_logging("main.log")
+
 app = FastAPI()
 
 class PredictionRequest(BaseModel):
@@ -12,27 +15,31 @@ class PredictionRequest(BaseModel):
 
 @app.on_event("startup")
 async def startup_event():
-    print("Initializing model...")
+    logger.info("Initializing model...")
     try:
         # Model initialization
         loader = ModelLoader()
         tokenizer, model = loader.load_model()
         pipeline = PipelinePreparer.prepare_pipeline(tokenizer, model)
         app.state.predictor = Predictor(pipeline)
-        print("Model initialized successfully")
+        logger.info("Model initialized successfully")
     except Exception as e:
-        print(f"Error initializing model: {e}")
+        logger.error(f"Error initializing model: {e}")
         app.state.predictor = None
 
 @app.get("/")
 def health_check():
+    logger.info("Health check endpoint called")
     return {"Message": "Service is healthy", "Status": "OK"}
 
 @app.post("/predict")
 def predict(request: PredictionRequest):
+    logger.info(f"Prediction request received: {request.sentence}")
     if not app.state.predictor:
+        logger.error("Model not initialized")
         return {"error": "Model not initialized"}
     return app.state.predictor.predict(request.sentence)
 
 if __name__ == "__main__":
+    logger.info("Starting FastAPI app...")
     uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+transformers
+torch

utils/commons.py

@@ -1,3 +1,24 @@
+import os
+import logging
+from pathlib import Path
+
 # Commonly used variables
 HUGGINGFACE_MODEL_PATH = "bespin-global/klue-roberta-small-3i4k-intent-classification"
-MODEL_SAVE_PATH = "./models"
+MODEL_SAVE_PATH = "./models"
+LOG_DIR = "logs/running_logs"
+
+# Ensure log directory exists
+Path(LOG_DIR).mkdir(parents=True, exist_ok=True)
+
+def setup_logging(log_file_name):
+    """Set up logging configuration."""
+    log_file = os.path.join(LOG_DIR, log_file_name)
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.FileHandler(log_file),
+            logging.StreamHandler()
+        ]
+    )
+    return logging.getLogger(__name__)