End-to-End Text Summarization Project

Text summarization is a crucial natural language processing task that automatically generates concise and coherent summaries from lengthy documents. This project delivers an end-to-end machine learning solution for abstractive text summarization using the powerful T5 (Text-to-Text Transfer Transformer) model.

Key Features of the Project

Project Workflow Overview

SAMSum Dataset Integration

The data ingestion pipeline automatically downloads the SAMSum dataset from the configured source URL and extracts it to the designated directory. The process ensures data integrity and proper folder structure for subsequent pipeline stages.

Configuration Setup

data_ingestion:
  root_dir: artifacts/data_ingestion
  source_URL: https://github.com/entbappy/Branching-tutorial/raw/master/summarizer-data.zip
  local_data_file: artifacts/data_ingestion/data.zip
  unzip_dir: artifacts/data_ingestion

The ingestion process creates a structured artifact directory that maintains data versioning and ensures reproducibility across different pipeline runs. The downloaded data is automatically validated for completeness before proceeding to the next stage.

Schema-Based Validation

Data validation ensures the integrity and completeness of the ingested dataset. The process verifies that all required files are present and accessible for the training pipeline.

Validation Configuration

data_validation:
  root_dir: artifacts/data_validation
  STATUS_FILE: artifacts/data_validation/status.txt
  ALL_REQUIRED_FILES: ["train", "test", "validation"]

Tokenization & Preprocessing Pipeline

Data transformation prepares the raw conversation data for training by tokenizing text using the T5 tokenizer. This process converts text into numerical representations that the transformer model can process effectively.

Transformation Configuration

data_transformation:
  root_dir: artifacts/data_transformation
  data_path: artifacts/data_ingestion/samsum_dataset
  tokenizer_name: t5-small

Tokenization Process

T5-Small Transformer Training

The model training stage fine-tunes the pre-trained T5-small model on the SAMSum dataset using optimized hyperparameters. The training process leverages HuggingFace's Trainer API for efficient distributed training and gradient accumulation.

Training Configuration

model_trainer:
  root_dir: artifacts/model_trainer
  data_path: artifacts/data_transformation/samsum_dataset
  model_ckpt: t5-small

Training Parameters

TrainingArguments:
  num_train_epochs: 1
  warmup_steps: 500
  per_device_train_batch_size: 4
  weight_decay: 0.01
  logging_steps: 10
  evaluation_strategy: steps
  eval_steps: 500
  save_steps: 1000000
  gradient_accumulation_steps: 8

ROUGE Metrics Assessment

Model evaluation employs ROUGE (Recall-Oriented Understudy for Gisting Evaluation) metrics to assess the quality of generated summaries. ROUGE measures the overlap between generated and reference summaries, providing comprehensive evaluation of summarization performance.

Evaluation Configuration

model_evaluation:
  root_dir: artifacts/model_evaluation
  data_path: artifacts/data_transformation/samsum_dataset
  model_path: artifacts/model_trainer/t5-small-samsum-model
  tokenizer_path: artifacts/model_trainer/tokenizer
  metric_file_name: artifacts/model_evaluation/metrics.csv

FastAPI & Docker Containerization

The deployment strategy leverages FastAPI for creating robust REST API endpoints and Docker for containerization. This approach ensures consistent deployment across different environments and provides scalable inference capabilities.

FastAPI Implementation

from fastapi import FastAPI
import uvicorn
from textSummarizer.pipeline.prediction import PredictionPipeline

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 successful !!")
    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=8080)

Docker Configuration

FROM python:3.8-slim-buster

RUN apt update -y && apt install awscli -y
WORKDIR /app

COPY . /app
RUN apt-get update && apt-get install -y build-essential python3-dev
RUN pip install -r requirements.txt
RUN pip install --upgrade accelerate
RUN pip uninstall -y transformers accelerate
RUN pip install transformers accelerate

CMD ["python3", "app.py"]

GitHub Actions Workflow

The CI/CD pipeline automates the entire deployment process from code push to production deployment on AWS. The workflow includes testing, building Docker images, pushing to AWS ECR, and deploying to EC2 instances.

AWS Deployment Architecture

Required AWS Policies

# IAM Policies Required:
1. AmazonEC2ContainerRegistryFullAccess
2. AmazonEC2FullAccess

# Description: About the deployment
1. Build docker image of the source code
2. Push your docker image to ECR
3. Launch Your EC2 
4. Pull Your image from ECR in EC2
5. Launch your docker image in EC2

GitHub Secrets Configuration

AWS_ACCESS_KEY_ID=your_access_key
AWS_SECRET_ACCESS_KEY=your_secret_key
AWS_REGION=us-east-1
AWS_ECR_LOGIN_URI=12345678.dkr.ecr.us-east-1.amazonaws.com
ECR_REPOSITORY_NAME=textsummarize

Docker Installation on EC2

# Optional
sudo apt-get update -y
sudo apt-get upgrade

# Required
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker ubuntu
newgrp docker