completed project AI Summarizer

.gitignore

@@ -2,7 +2,7 @@
 __pycache__/
 *.py[cod]
 *$py.class
-
+artifacts/
 # C extensions
 *.so
 

app.py

@@ -0,0 +1,39 @@
+from fastapi import FastAPI
+import uvicorn
+import sys
+import os
+from fastapi.templating import Jinja2Templates
+from starlette.responses import RedirectResponse
+from fastapi.responses import Response
+from textSummarizer.pipeline.prediction import PredictionPipeline
+
+txt:str = "What is Text Summarization?"
+
+app = FastAPI()
+
+@app.get("/", tags=["authentication"] )
+async def index():
+    return RedirectResponse(url="/docs")
+
+
+@app.get("/train")
+async def training():
+    try:
+        os.system("python main.py")
+        return Response("Training completed successfully!")
+    except Exception as e:
+        return Response(f"Error Occurred! {e}")
+    
+    
+@app.post("/predict")
+async def predict_route(text):
+    try:
+        
+        obj = PredictionPipeline()
+        text = obj.predict(text)
+        return text
+    except Exception as e:
+        raise e
+    
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

config/config.yaml

@@ -29,6 +29,6 @@ model_trainer:
 model_evaluation:
   root_dir: artifacts/model_evaluation
   data_path: artifacts/data_transformation/samsum_dataset
-  model_path: artifacts/model_trainer/pegasus-samsum_model
-  tokenizer_path: artifacts/model_trainer/tokenizer_name
+  model_path: artifacts/model_trainer/pegasus-samsum-model
+  tokenizer_path: artifacts/model_trainer/tokenizer
   metric_file_name: artifacts/model_evaluation/metrics.csv

main.py

@@ -2,6 +2,7 @@ from textSummarizer.pipeline.stage_01_data_ingestion import DataIngestionTrainin
 from textSummarizer.pipeline.stage_02_data_validation import DataValidationTrainingPipeline
 from textSummarizer.pipeline.stage_03_data_transformation import DataTransformationTrainingPipeline
 from textSummarizer.pipeline.stage_04_model_trainer import ModelTrainerTrainingPipeline
+from textSummarizer.pipeline.stage_05_model_evaluation import ModelEvaluationTrainingPipeline
 from textSummarizer.logging import logger
 
 
@@ -45,6 +46,18 @@ try:
     model_trainer = ModelTrainerTrainingPipeline()
     model_trainer.main()
     logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx============x")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+
+STAGE_NAME = "Model Evaluation Stage"
+try:
+    logger.info(f"********************************")
+    logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<")
+    model_evaluation = ModelEvaluationTrainingPipeline()
+    model_evaluation.main()
+    logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx============x")
 except Exception as e:
     logger.exception(e)
     raise e

src/textSummarizer/components/data_ingestion.py

@@ -10,25 +10,31 @@ class DataIngestion:
     def __init__(self, config: DataIngestionConfig):
         self.config = config
         
-        
     def download_data(self):
-        if not os.path.exists(self.config.local_data_file):
-            filename, headers = request.urlretrieve(
-            url = self.config.source_URL,
-            filename = self.config.local_data_file
-            )
-            logger.info(f"{filename} download! with following info : \n{headers}")
-        else:
-            logger.info(f"File already exists of size : {get_size(Path(self.config.local_data_file))}")
+        try:
+            if not self.config.local_data_file.exists():
+                filename, headers = request.urlretrieve(
+                    url=self.config.source_URL,
+                    filename=str(self.config.local_data_file)
+                )
+                logger.info(f"{filename} downloaded with info: {headers}")
+            else:
+                logger.info(f"File already exists of size: {get_size(self.config.local_data_file)}")
+        except Exception as e:
+            logger.error(f"Error downloading data: {e}")
+            raise e
             
     def extract_zip_file(self):
         """
-        zip_file_path : str
-        EXtracts the zip file to the given directory.
-        Functions returns None.
+        Extracts the zip file located at `local_data_file` to the directory `unzip_dir`.
         """
-        unzip_path = self.config.unzip_dir
-        os.makedirs(unzip_path, exist_ok=True)
-        with zipfile.ZipFile(self.config.local_data_file, 'r') as zip_ref:
-            zip_ref.extractall(unzip_path)
-            
+        try:
+            unzip_path = self.config.unzip_dir
+            os.makedirs(unzip_path, exist_ok=True)
+            logger.info(f"Extracting {self.config.local_data_file} to {unzip_path}")
+            with zipfile.ZipFile(self.config.local_data_file, 'r') as zip_ref:
+                zip_ref.extractall(unzip_path)
+            logger.info("Extraction completed.")
+        except Exception as e:
+            logger.error(f"Error extracting zip file: {e}")
+            raise e

src/textSummarizer/components/data_transformation.py

@@ -4,28 +4,34 @@ from transformers import AutoTokenizer
 from datasets import load_dataset, load_from_disk
 from textSummarizer.entity import DataTransformationConfig
 
-
 class DataTransformation:
     def __init__(self, config: DataTransformationConfig):
         self.config = config
         self.tokenizer = AutoTokenizer.from_pretrained(self.config.tokenizer_name)
         
-        
     def convert_examples_to_features(self, example_batch):
-        input_encodings = self.tokenizer(example_batch['dialogue'] , max_length=1024, truncation=True)
-        
-        with self.tokenizer.as_target_tokenizer():
-            target_encodings = self.tokenizer(example_batch['summary'], max_length=128, truncation=True)
-        
+        input_encodings = self.tokenizer(
+            example_batch['dialogue'],
+            max_length=1024,
+            truncation=True
+        )
+        target_encodings = self.tokenizer(
+            text_target=example_batch['summary'],
+            max_length=128,
+            truncation=True
+        )
         return {
             'input_ids': input_encodings['input_ids'],
             'attention_mask': input_encodings['attention_mask'],
             'labels': target_encodings['input_ids'],
         }
         
-        
     def convert(self):
-        dataset_samsum = load_from_disk(self.config.data_path)
+        logger.info(f"Loading dataset from {self.config.data_path}")
+        dataset_samsum = load_from_disk(str(self.config.data_path))
+        logger.info("Tokenizing dataset...")
         dataset_samsum_pt = dataset_samsum.map(self.convert_examples_to_features, batched=True)
-        dataset_samsum_pt.save_to_disk(os.path.join(self.config.root_dir, "samsum_dataset"))
-        
+        save_path = self.config.root_dir / "samsum_dataset"
+        os.makedirs(save_path, exist_ok=True)
+        logger.info(f"Saving processed dataset to {save_path}")
+        dataset_samsum_pt.save_to_disk(str(save_path))

src/textSummarizer/components/data_validation.py

@@ -5,26 +5,29 @@ from textSummarizer.entity import DataValidationConfig
 class DataValidation:
     def __init__(self, config: DataValidationConfig):
         self.config = config
-        
-        
-        
+
     def validate_all_files_exists(self) -> bool:
         try:
-            validation_status = None
-            
-            all_files = os.listdir(os.path.join("artifacts" , "data_ingestion" , "samsum_dataset"))
-            
-            for file in all_files:
-                if file not in self.config.ALL_REQUIRED_FILES:
-                    validation_status = False
-                    with open(self.config.STATUS_FILE, 'w') as f:
-                        f.write(f"Validation status: {validation_status}")
+            # Use config for dataset directory
+            dataset_dir = self.config.root_dir
+            all_files = set(os.listdir(dataset_dir))
+
+            required_files = set(self.config.ALL_REQUIRED_FILES)
+            missing_files = required_files - all_files
+
+            validation_status = len(missing_files) == 0
+
+            # Write status to file
+            with open(self.config.STATUS_FILE, 'w') as f:
+                if validation_status:
+                    f.write("Validation status: True\nAll required files are present.")
+                    logger.info("All required files are present.")
                 else:
-                    validation_status = True
-                    with open(self.config.STATUS_FILE, 'w') as f:
-                        f.write(f"Validation status: {validation_status}")
-                        
+                    f.write(f"Validation status: False\nMissing files: {', '.join(missing_files)}")
+                    logger.warning(f"Missing files: {', '.join(missing_files)}")
+
             return validation_status
-        
+
         except Exception as e:
-            raise e
+            logger.error(f"Validation failed: {e}")
+            raise e

src/textSummarizer/components/model_evaluation.py

@@ -0,0 +1,67 @@
+import os
+import evaluate
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+from textSummarizer.entity import ModelEvaluationConfig
+from datasets import load_from_disk
+import torch
+import pandas as pd
+from tqdm import tqdm
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ModelEvaluation:
+    def __init__(self, config: ModelEvaluationConfig):
+        self.config = config
+
+    def generate_batch_sized_chunks(self, list_of_elements, batch_size):
+        for i in range(0, len(list_of_elements), batch_size):
+            yield list_of_elements[i : i + batch_size]
+
+    def calculate_metric_on_test_ds(self, dataset, metric, model, tokenizer, 
+                                    batch_size=16, device="cuda" if torch.cuda.is_available() else "cpu", 
+                                    column_text="article", column_summary="highlights"):
+        article_batches = list(self.generate_batch_sized_chunks(dataset[column_text], batch_size))
+        target_batches = list(self.generate_batch_sized_chunks(dataset[column_summary], batch_size))
+
+        for article_batch, target_batch in tqdm(
+            zip(article_batches, target_batches), total=len(article_batches)):
+            
+            inputs = tokenizer(article_batch, max_length=1024,  truncation=True, 
+                            padding="max_length", return_tensors="pt")
+            
+            summaries = model.generate(input_ids=inputs["input_ids"].to(device),
+                            attention_mask=inputs["attention_mask"].to(device), 
+                            length_penalty=0.8, num_beams=8, max_length=128)
+            
+            decoded_summaries = [tokenizer.decode(s, skip_special_tokens=True, clean_up_tokenization_spaces=True) 
+                                 for s in summaries]
+            
+            metric.add_batch(predictions=decoded_summaries, references=target_batch)
+            
+        score = metric.compute()
+        return score
+
+    def evaluate(self):
+        logger.info("Loading tokenizer and model...")
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        tokenizer = AutoTokenizer.from_pretrained(self.config.tokenizer_path)
+        model_pegasus = AutoModelForSeq2SeqLM.from_pretrained(self.config.model_path).to(device)
+       
+        logger.info("Loading dataset...")
+        dataset_samsum_pt = load_from_disk(self.config.data_path)
+
+        rouge_names = ["rouge1", "rouge2", "rougeL", "rougeLsum"]
+        rouge_metric = evaluate.load('rouge')
+
+        logger.info("Starting evaluation...")
+        score = self.calculate_metric_on_test_ds(
+            dataset_samsum_pt['test'][0:10], rouge_metric, model_pegasus, tokenizer, batch_size=2, 
+            column_text='dialogue', column_summary='summary'
+        )
+
+        rouge_dict = {rn: score[rn] for rn in rouge_names}
+
+        df = pd.DataFrame(rouge_dict, index=['pegasus'])
+        logger.info(f"Saving metrics to {self.config.metric_file_name}")
+        df.to_csv(self.config.metric_file_name, index=False)

src/textSummarizer/config/configuration.py

@@ -3,7 +3,8 @@ from textSummarizer.utils.common import read_yaml, create_directories
 from textSummarizer.entity import (DataIngestionConfig,
                                    DataValidationConfig,
                                    DataTransformationConfig,
-                                   ModelTrainerConfig)
+                                   ModelTrainerConfig,
+                                   ModelEvaluationConfig)
 
 
 class ConfigurationManager:
@@ -24,10 +25,10 @@ class ConfigurationManager:
         create_directories([config.root_dir])
         
         data_ingestion_config = DataIngestionConfig(
-            root_dir = config.root_dir,
+            root_dir = Path(config.root_dir),
             source_URL = config.source_URL,
-            local_data_file = config.local_data_file,
-            unzip_dir = config.unzip_dir,
+            local_data_file = Path(config.local_data_file),
+            unzip_dir = Path(config.unzip_dir),
         )
         
         return data_ingestion_config
@@ -53,9 +54,9 @@ class ConfigurationManager:
         create_directories([config.root_dir])
         
         data_transformation_config = DataTransformationConfig(
-            root_dir=config.root_dir,
-            data_path=config.data_path,
-            tokenizer_name=config.tokenizer_name,
+            root_dir=Path(config.root_dir),
+            data_path=Path(config.data_path),
+            tokenizer_name=config.tokenizer_name,  # if this is a path, use Path(); if just a model name, keep as str
         )
         
         return data_transformation_config
@@ -82,4 +83,21 @@ class ConfigurationManager:
             gradient_accumulation_steps=params.gradient_accumulation_steps
         )
         
-        return model_trainer_config
+        return model_trainer_config
+    
+    
+    def get_model_evaluation_config(self) -> ModelEvaluationConfig:
+        config = self.config.model_evaluation
+
+        create_directories([config.root_dir])
+
+        model_evaluation_config = ModelEvaluationConfig(
+            root_dir=config.root_dir,
+            data_path=config.data_path,
+            model_path = config.model_path,
+            tokenizer_path = config.tokenizer_path,
+            metric_file_name = config.metric_file_name
+           
+        )
+
+        return model_evaluation_config

src/textSummarizer/entity/__init__.py

@@ -37,4 +37,13 @@ class ModelTrainerConfig:
     evaluation_strategy: str
     eval_steps: int
     save_steps: float
-    gradient_accumulation_steps: int   
+    gradient_accumulation_steps: int   
+    
+    
+@dataclass(frozen=True)
+class ModelEvaluationConfig:
+    root_dir: Path
+    data_path: Path
+    model_path: Path
+    tokenizer_path: Path
+    metric_file_name: Path

src/textSummarizer/pipeline/prediction.py

@@ -0,0 +1,23 @@
+from textSummarizer.config.configuration import ConfigurationManager
+from transformers import AutoTokenizer
+from transformers import pipeline
+
+class PredictionPipeline:
+    def __init__(self):
+        self.config = ConfigurationManager().get_model_evaluation_config()
+        
+        
+    def predict(self, text):
+        tokenizer = AutoTokenizer.from_pretrained(self.config.tokenizer_path)
+        gen_kwargs = {"length_penalty": 0.8, "num_beams": 8 , "max_length":128 }
+        
+        pipe = pipeline('summarization', model=self.config.model_path, tokenizer=tokenizer)
+        
+        print("Dialogue:")
+        print(text)
+        
+        output = pipe(text, **gen_kwargs)[0]['summary_text']
+        print("\nModel Summary:")
+        print(output)
+        
+        return output

src/textSummarizer/pipeline/stage_04_model_trainer.py

@@ -9,7 +9,7 @@ class ModelTrainerTrainingPipeline:
     def main(self):
         config = ConfigurationManager()
         model_trainer_config = config.get_model_trainer_config()
-        model_trainer_config = ModelTrainer(config=model_trainer_config)
-        model_trainer_config.train()
+        model_trainer = ModelTrainer(config=model_trainer_config)
+        model_trainer.train()
         
         

src/textSummarizer/pipeline/stage_05_model_evaluation.py

@@ -0,0 +1,16 @@
+from textSummarizer.config.configuration import ConfigurationManager
+from textSummarizer.components.model_evaluation import ModelEvaluation
+from textSummarizer.logging import logger
+
+
+
+class ModelEvaluationTrainingPipeline:
+    def __init__(self):
+        pass
+    
+    def main(self):
+        config = ConfigurationManager()
+        model_evaluation_config = config.get_model_evaluation_config()
+        model_evaluation = ModelEvaluation(config=model_evaluation_config)
+        model_evaluation.evaluate()
+