initial commit

.gitignore

@@ -0,0 +1,3 @@
+*.ipynb_checkpoints
+__pycache__
+*.json

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.10
+ENV PATH="/root/miniconda3/bin:${PATH}"
+ARG PATH="/root/miniconda3/bin:${PATH}"
+RUN apt-get update
+
+RUN apt-get install -y wget tesseract-ocr libtesseract-dev && rm -rf /var/lib/apt/lists/*
+
+RUN wget \
+	https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \
+	&& mkdir /root/.conda \
+	&& bash Miniconda3-latest-Linux-x86_64.sh -b \
+	&& rm -f Miniconda3-latest-Linux-x86_64.sh
+RUN conda --version
+
+RUN conda install -c conda-forge poppler -y
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+RUN echo $pwd
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,48 @@
+import gradio as gr
+from inference import Inference
+
+
+def predict_url_class(url):
+    """Predicts the class of the given pdf url. Creates the output necessary for gradio Label."""
+    inference = Inference(pdf_url=url)
+    try:
+        outputs = inference.predict()
+    except Exception as e:
+        gr.Warning(e)
+    output_for_gradio = {
+        "Lighting": outputs[0],
+        "Non-Lighting": outputs[1],
+    }
+    return output_for_gradio
+
+
+def main():
+    # Define Gradio interface
+    description = "<p>The model in trained on a number of PDFs related to lighting and non-lighting products. The model takes an URL as input and predicts whether the product in the PDF corresponds to a Ligthing product or not. The model may take upto 30 second to make a prediction. This is because we need to first extract textual, tabular and image information from various pages of the PDF and this may a long time. Make sure that the URL provided is unblocked and can be downloaded without any extra steps.</p>"
+    inputs = gr.Text(lines=1, placeholder="Enter the url of the PDF", label="URL")
+    outputs = gr.Label(
+        num_top_classes=2,
+        label="Prediction",
+        every=2,
+    )
+    gradio_app = gr.Interface(
+        fn=predict_url_class,
+        inputs=inputs,
+        outputs=outputs,
+        title="PDF",
+        description=description,
+        theme="snehilsanyal/scikit-learn",
+        examples=[
+            [
+                "https://www.topbrasslighting.com/wp-content/uploads/TopBrass-138.01-tearsheet-Jun12018.pdf"
+            ],
+            ["https://lyntec.com/wp-content/uploads/2018/12/LynTec-XPC-Brochure.pdf"],
+        ],
+        allow_flagging="never",
+    )
+    gradio_app.queue().launch(server_name="0.0.0.0", server_port=7860)
+
+
+if __name__ == "__main__":
+    # Run Gradio app
+    main()

create_dataset.py

@@ -0,0 +1,171 @@
+from utilities import get_simple_logger, PDFExtractor, ModuleException
+import pandas as pd
+import os, glob
+import json
+from tqdm.auto import tqdm
+import re
+
+file_dir = os.path.dirname(os.path.realpath(__file__))
+csv_file_dir = os.path.join(file_dir, "materials")
+data_dir = os.path.join(file_dir, "data")
+train_json_dir = os.path.join(data_dir, "train_jsons")
+test_json_dir = os.path.join(data_dir, "test_jsons")
+
+logger = get_simple_logger("create_dataset")
+
+
+def save_json(data, split="train"):
+    id_ = data["id"]
+    if split == "train":
+        to_save = os.path.join(train_json_dir, f"{id_}.json")
+    else:
+        to_save = os.path.join(test_json_dir, f"{id_}.json")
+    logger.debug(f"Saving the json to {to_save}")
+    with open(to_save, "w") as f:
+        json.dump(data, f)
+
+
+def clean_text(text):
+    # Clean the text by
+    # remove extra whitespace
+    regex = re.compile(r"\s{2,}")
+    text = regex.sub(" ", text)
+    # removing more than one new line with a single new line
+    regex = re.compile(r"\n{2,}")
+    text = regex.sub("\n", text)
+    # if each line has less than 3 characters, remove it
+    lines = text.split("\n")
+    lines = [line for line in lines if len(line) > 3]
+    text = "\n".join(lines)
+    # cap max to 10000
+    text = text[:10000]
+    return text
+
+
+def create_id(id_, split):
+    id_ = int(id_)
+    if split == "train":
+        return f"P-{id_}"
+    else:
+        return f"TP{id_}"
+
+
+def create_json(split="train"):
+    """Creates the dataset from the csv file and saves it to the data_dir
+
+    Parameters
+    ----------
+    split : str, optional
+        The split to create the dataset for, by default "train"
+    """
+    logger.info(f"Creating the dataset for {split}")
+    df_path = os.path.join(csv_file_dir, f"parspec_{split}_data.csv")
+    df = pd.read_csv(df_path)
+    df.dropna(inplace=True)
+    json_dir = train_json_dir if split == "train" else test_json_dir
+    os.makedirs(json_dir, exist_ok=True)
+
+    # already extracted files
+    extracted_files = os.listdir(json_dir)
+    extracted_files = list(map(lambda x: x.split(".")[0], os.listdir(train_json_dir)))
+    logger.info(f"{len(extracted_files)} files are already extracted.")
+
+    for i, row in tqdm(
+        df.iterrows(),
+        desc="extracting information...",
+        total=len(df) - len(extracted_files),
+    ):
+        # if i == 3:
+        #     break
+        id_ = row["ID"]
+        if "-" in id_:
+            # for train
+            id_ = id_.split("-")[1]
+        else:
+            # for test
+            id_ = id_[2:]
+        id_ = id_.zfill(4)
+        if id_ in extracted_files:
+            logger.debug(f"File {id_} already extracted")
+            continue
+        logger.info(f"Extracting the file for ID {id_}")
+        url = row["URL"]
+        label = 1 if row["Is lighting product?"] in [1, "Yes"] else 0
+        try:
+            pdf_extractor = PDFExtractor(
+                file_path=url,
+                is_url=True,
+                min_characters=5,
+                maximum_pages=3,
+            )
+            final = pdf_extractor.extract_pages()
+            data = {
+                "status": "ok",
+                "id": id_,
+                "label": label,
+                "page_contents": pdf_extractor.page_contents,
+                "final_content": clean_text(final),
+                "url": url,
+            }
+        # save the json
+        except ModuleException:
+            logger.error(f"Url is not valid for ID {id_}. Using Null values.")
+            data = {
+                "status": "error",
+                "id": id_,
+                "label": label,
+                "page_contents": None,
+                "final_content": None,
+                "url": url,
+            }
+        save_json(data, split)
+
+
+def create_dataframe(split):
+    df_path = os.path.join(csv_file_dir, f"parspec_{split}_data.csv")
+    df = pd.read_csv(df_path)
+    json_dir = train_json_dir if split == "train" else test_json_dir
+    json_files = glob.glob(f"{json_dir}/*.json")
+    statuss = []
+    ids = []
+    labels = []
+    contents = []
+    urls = []
+    for file in tqdm(json_files, "creating dataframe..."):
+        with open(file, "r") as f:
+            data = json.load(f)
+            if data["status"] == "error":
+                continue
+            statuss.append(data["status"])
+            ids.append(create_id(data["id"], split=split))
+            labels.append(data["label"])
+            contents.append(clean_text(data["final_content"]))
+            urls.append(data["url"])
+
+    final_df = pd.DataFrame(
+        {
+            "status": statuss,
+            "id": ids,
+            "label": labels,
+            "content": contents,
+            "url": urls,
+        }
+    )
+    final = pd.merge(final_df, df, left_on="id", right_on="ID")[
+        ["id", "content", "Is lighting product?", "url"]
+    ]
+    final.rename(columns={"Is lighting product?": "label"}, inplace=True)
+    final["label"] = final["label"].map(
+        {
+            "Yes": 1,
+            "No": 0,
+        }
+    )
+    final.to_csv(
+        os.path.join(data_dir, f"{split}.csv"), index=False, escapechar="\\"
+    )  # setting escapechar is required
+    return final
+
+
+if __name__ == "__main__":
+    create_dataframe(split="test")

encoder/config.json

@@ -0,0 +1,26 @@
+{
+  "_name_or_path": "sentence-transformers/paraphrase-MiniLM-L3-v2",
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 3,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "float32",
+  "transformers_version": "4.35.2",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

encoder/model.safetensors

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

encoder/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

encoder/tokenizer_config.json

@@ -0,0 +1,64 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "max_length": 128,
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_to_multiple_of": null,
+  "pad_token": "[PAD]",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "[SEP]",
+  "stride": 0,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "[UNK]"
+}

final_model.pkl

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

inference.py

@@ -0,0 +1,88 @@
+from utilities import (
+    PDFExtractor,
+    get_simple_logger,
+    ModuleException,
+)
+from create_dataset import clean_text
+from model import PDFDataSet
+import pickle
+import argparse
+
+
+class Inference:
+    """A class that does inference given a url of the pdf. Uses the saved RandomForest model for inference."""
+
+    def __init__(self, pdf_url, model_path="final_model.pkl") -> None:
+        self.pdf_url = pdf_url
+        self.model_path = model_path
+        self.logger = get_simple_logger("inference", level="debug")
+
+    def _extract_text(self):
+        self.logger.debug("Extracting text from the PDF.")
+        pdf_extractor = PDFExtractor(
+            self.pdf_url,
+            min_characters=5,
+            maximum_pages=3,
+        )
+        try:
+            final = pdf_extractor.extract_pages()
+            data = {
+                "status": "ok",
+                "id": "001",
+                "page_contents": pdf_extractor.page_contents,
+                "final_content": clean_text(final),
+                "url": self.pdf_url,
+            }
+        except ModuleException as e:
+            self.logger.warning("A module exception is raised.")
+            self.logger.error(e)
+            raise e
+        except Exception as e:
+            self.logger.error(e)
+            raise e
+        return data, final
+
+    def _load_model(self):
+        with open(self.model_path, "rb") as f:
+            model = pickle.load(f)
+        self.model = model
+        return self.model
+
+    def _create_embedding(self, text):
+        dataset = PDFDataSet()
+        embedding = dataset.sentences_to_embedding([text])
+        return embedding.reshape(1, -1)
+
+    def _pretty_print_probability(self, p):
+        non_lighting_probability = p[0] * 100
+        lighting_probablity = p[1] * 100
+        if lighting_probablity > non_lighting_probability:
+            print(
+                f"This is a Lighting product with a probability of {lighting_probablity:.2f}%"
+            )
+        else:
+            print(
+                f"This is a Non-Lighting product with a probability of {non_lighting_probability:.2f}%"
+            )
+
+    def predict(self):
+        _, sentence = self._extract_text()
+        embedding = self._create_embedding(sentence)
+        model = self._load_model()
+        prediction = model.predict_proba(embedding)
+        prediction = prediction[0]
+        self._pretty_print_probability(prediction)
+        return prediction
+
+
+def main(args):
+    inference = Inference(args.url)
+    prediction = inference.predict()
+    print(prediction)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", type=str, required=True)
+    args = parser.parse_args()
+    main(args)

model.py

@@ -0,0 +1,382 @@
+from transformers import AutoTokenizer, AutoModel
+from datasets import load_dataset, Dataset, concatenate_datasets
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import (
+    classification_report,
+    confusion_matrix,
+    accuracy_score,
+    precision_score,
+)
+from sklearn.ensemble import RandomForestClassifier
+from xgboost import XGBClassifier
+import torch.nn as nn
+import torchmetrics
+from torch.optim.lr_scheduler import CosineAnnealingLR
+
+import numpy as np
+import pandas as pd
+import os
+import pickle
+import argparse
+from torch_train import TorchTrain
+from utilities import get_simple_logger
+
+FILE_DIR = os.path.dirname(os.path.realpath(__file__))
+DATA_DIR = os.path.join(FILE_DIR, "data")
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+random_state = 42
+# set random state
+np.random.seed(random_state)
+torch.manual_seed(random_state)
+
+
+class PDFDataLoader:
+    def __init__(self, df):
+        self.df = df
+
+    def __getitem__(self, idx):
+        row = self.df[idx]
+        embeddings = row["embeddings"]
+        label = row["label"]
+        # convert to torch int
+        label = np.array(label)
+        # add extra dimension to label
+        label = np.expand_dims(label, axis=0)
+        embeddings = torch.from_numpy(np.array(embeddings)).float()
+        return embeddings.to(device), torch.from_numpy(label).to(device).float()
+
+    def __len__(self):
+        return len(self.df)
+
+
+class PDFDataSet:
+    def __init__(
+        self,
+        data_dir=DATA_DIR,
+        fraction_test_data_in_train=0.2,
+        model_ckpt="encoder",
+    ) -> None:
+        self.data_dir = data_dir
+        self.fraction_test_data_in_train = fraction_test_data_in_train
+        self.model_ckpt = model_ckpt
+        tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
+        encoding_model = AutoModel.from_pretrained(model_ckpt)
+        encoding_model = encoding_model.to(device)
+        encoding_model = encoding_model.eval()
+        self.encoding_model = encoding_model
+        self.tokenizer = tokenizer
+        self.logger = get_simple_logger("pdf_dataset")
+
+    def create_datasets(self):
+        train_data_path = os.path.join(FILE_DIR, self.data_dir, "train.csv")
+        test_data_path = os.path.join(FILE_DIR, self.data_dir, "test.csv")
+        df = pd.read_csv(train_data_path)
+        test_df = pd.read_csv(test_data_path)
+        train_df, validation_df = train_test_split(df, test_size=0.3, random_state=42)
+        if self.fraction_test_data_in_train:
+            self.logger.info(
+                f"Adding {self.fraction_test_data_in_train} fraction of test dataset to the training set."
+            )
+            test_df, test_df_for_training = train_test_split(
+                test_df, test_size=self.fraction_test_data_in_train, random_state=42
+            )
+            train_df = pd.concat([train_df, test_df_for_training])
+
+        train_dataset = Dataset.from_pandas(train_df)
+        validation_dataset = Dataset.from_pandas(validation_df)
+        test_dataset = Dataset.from_pandas(test_df)
+        return train_dataset, validation_dataset, test_dataset
+
+    def mean_pooling(self, model_output, attention_mask):
+        token_embeddings = model_output[
+            0
+        ]  # First element of model_output contains all token embeddings
+        input_mask_expanded = (
+            attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        )
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(
+            input_mask_expanded.sum(1), min=1e-9
+        )
+
+    def sentences_to_embedding(self, sentences):
+        # Tokenize sentences
+        encoded_input = self.tokenizer(
+            sentences, padding=True, truncation=True, return_tensors="pt"
+        )
+        sentence_embeddings = self.mean_pooling(
+            self.encoding_model(**encoded_input), encoded_input["attention_mask"]
+        )
+        sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)
+        # remove last dimension
+        sentence_embeddings = sentence_embeddings.squeeze()
+        return sentence_embeddings.detach()
+
+    def get_embeddings(self, row):
+        return {
+            "embeddings": self.sentences_to_embedding(
+                sentences=row["content"],
+            )
+        }
+
+    def create_embeddings(self):
+        train_dataset, validation_dataset, test_dataset = self.create_datasets()
+        train_dataset = train_dataset.map(self.get_embeddings)
+        validation_dataset = validation_dataset.map(self.get_embeddings)
+        test_dataset = test_dataset.map(self.get_embeddings)
+        return train_dataset, validation_dataset, test_dataset
+
+
+class PDFModel(nn.Module):
+    def __init__(self, input_size, hidden_sizes, output_size):
+        super(PDFModel, self).__init__()
+        self.seq_model = nn.Sequential()
+        for i, hidden_size in enumerate(hidden_sizes):
+            self.seq_model.add_module(f"linear_{i}", nn.Linear(input_size, hidden_size))
+            self.seq_model.add_module(f"relu_{i}", nn.ReLU())
+            input_size = hidden_size
+        self.last_layer = nn.Linear(input_size, output_size)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        seq_out = self.seq_model(x)
+        out = self.last_layer(seq_out)
+        return self.sigmoid(out)
+
+
+def evaluate_model(y_true, y_pred, model_name, split="train"):
+    accuracy = accuracy_score(y_true, y_pred)
+    precision = precision_score(y_true, y_pred)
+    classification_report_ = classification_report(y_true, y_pred)
+    print("------" * 10)
+    print(f"Evaluating for the model: {model_name} for {split} dataset...")
+    print(f"Accuracy: {accuracy}")
+    print(f"Precision: {precision}")
+    print(classification_report_)
+    print("------" * 10)
+
+
+def train_dl_model(
+    train_data,
+    validation_data,
+    epochs=30,
+    input_shape=384,
+    hidden_sizes=[32, 16],
+):
+    model = PDFModel(input_size=input_shape, hidden_sizes=hidden_sizes, output_size=1)
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+    loss_fn = nn.BCELoss()
+    accuracy = torchmetrics.Accuracy(
+        task="binary", num_classes=2, threshold=0.5, average="macro"
+    )
+    precision = torchmetrics.Precision(task="binary", average="macro")
+    metrics = {
+        "accuracy": accuracy,
+        "precision": precision,
+    }
+    scheduler = CosineAnnealingLR(optimizer, T_max=10, eta_min=0.0001)
+    tt = TorchTrain(model, optimizer, loss_fn, metrics=metrics, scheduler=scheduler)
+    history = tt.fit(train_data, validation_data, verbose=True, epochs=epochs)
+    return history, model
+
+
+def evaluate_models(fraction_test_data_in_train=0.1):
+    print("Creating Embeddings...")
+    ds = PDFDataSet(fraction_test_data_in_train=fraction_test_data_in_train)
+    train_dataset, validation_dataset, test_dataset = ds.create_embeddings()
+    print("Done\n")
+
+    print("Training DL Model")
+    # Create dataset for DL models:
+    BATCH_SIZE = 8
+    train_dataloader = PDFDataLoader(train_dataset)
+    validation_dataloader = PDFDataLoader(validation_dataset)
+    test_dataloader = PDFDataLoader(test_dataset)
+
+    train_data = DataLoader(train_dataloader, batch_size=BATCH_SIZE, shuffle=True)
+    validation_data = DataLoader(
+        validation_dataloader,
+        batch_size=BATCH_SIZE,
+        shuffle=True,
+    )
+    test_data = DataLoader(test_dataloader, batch_size=BATCH_SIZE, shuffle=True)
+    for X, y in train_data:
+        input_shape = int(X.shape[1])
+        output_shape = int(y.shape[1])
+        break
+    epochs = 30
+    hidden_sizes = [32, 16]
+    history, model = train_dl_model(
+        train_data=train_data,
+        validation_data=validation_data,
+        epochs=epochs,
+        hidden_sizes=hidden_sizes,
+    )
+    print("Done\n")
+    print("Evaluating DL Model")
+    y_test_pred = model(torch.from_numpy(np.array(test_dataset["embeddings"])).float())
+    y_test_pred = y_test_pred.detach().numpy()
+    y_test_pred = np.where(y_test_pred > 0.5, 1, 0)
+    evaluate_model(
+        y_true=test_dataset["label"],
+        y_pred=y_test_pred,
+        model_name="DL Model",
+        split="test",
+    )
+    print("Done\n")
+
+    # ML Models
+    print("Training and evaluating ML Models.")
+    X_train = train_dataset["embeddings"]
+    y_train = train_dataset["label"]
+    X_validation = validation_dataset["embeddings"]
+    y_validation = validation_dataset["label"]
+    X_test = test_dataset["embeddings"]
+    y_test = test_dataset["label"]
+    rfc_best_params = {
+        "max_depth": 23,
+        "max_features": "log2",
+        "n_estimators": 469,
+    }
+
+    xgb_best_params = {
+        "max_depth": 25,
+        "n_estimators": 372,
+        "learning_rate": 0.2522824287799319,
+    }
+    print("Fitting RandomForest")
+    rfc = RandomForestClassifier(**rfc_best_params)
+    rfc.fit(X_train, y_train)
+    evaluate_model(
+        y_true=y_train,
+        y_pred=rfc.predict(X_train),
+        model_name="RandomForest",
+        split="train",
+    )
+    evaluate_model(
+        y_true=y_validation,
+        y_pred=rfc.predict(X_validation),
+        model_name="RandomForest",
+        split="validation",
+    )
+    evaluate_model(
+        y_true=y_test,
+        y_pred=rfc.predict(X_test),
+        model_name="RandomForest",
+        split="test",
+    )
+
+    print("Fitting XGBoost")
+    xgb = XGBClassifier(**xgb_best_params)
+    xgb.fit(X_train, y_train)
+    evaluate_model(
+        y_true=y_train,
+        y_pred=xgb.predict(X_train),
+        model_name="XGBoost",
+        split="train",
+    )
+    evaluate_model(
+        y_true=y_validation,
+        y_pred=xgb.predict(X_validation),
+        model_name="XGBoost",
+        split="validation",
+    )
+    evaluate_model(
+        y_true=y_test,
+        y_pred=xgb.predict(X_test),
+        model_name="XGBoost",
+        split="test",
+    )
+    print("All Done")
+
+
+def train_and_save_final_model(model_save_path="final_model.pkl"):
+    """This method creats and save the final model. The final model has the following characterstics:
+
+    - It is a RandomForestClassifier trained on all the training data and 10% of the test data. 10% of the test data. The 10% of test data is necessary as the distribution of the test data is very different from the training data.
+    - Since 10% of test data is used while training, this data is not used while claculating the final accuracy of the model, which is 100%.
+
+    Parameters
+    ----------
+    model_save_path : str, optional
+        The path to save the final model, by default "final_model.pkl"
+    Returns
+    -------
+    None
+    Examples
+    --------
+    >>> train_and_save_final_model()
+    >>> train_and_save_final_model(model_save_path="final_model.pkl")
+    """
+    print("Creating Embeddings...")
+    model_save_path = os.path.join(FILE_DIR, model_save_path)
+    ds = PDFDataSet(fraction_test_data_in_train=0.1)
+    train_dataset, validation_dataset, test_dataset = ds.create_embeddings()
+    train_dataset = concatenate_datasets([train_dataset, validation_dataset])
+    X_train = train_dataset["embeddings"]
+    X_test = test_dataset["embeddings"]
+    y_train = train_dataset["label"]
+    y_test = test_dataset["label"]
+
+    print("Training and evaluating the model...")
+    rfc_best_params = {
+        "max_depth": 23,
+        "max_features": "log2",
+        "n_estimators": 469,
+    }
+    rfc_model = RandomForestClassifier(**rfc_best_params)
+    rfc_model.fit(X_train, y_train)
+    evaluate_model(
+        y_true=y_train,
+        y_pred=rfc_model.predict(X_train),
+        model_name="Final Model",
+        split="train",
+    )
+    evaluate_model(
+        y_true=y_test,
+        y_pred=rfc_model.predict(X_test),
+        model_name="Final Model",
+        split="test",
+    )
+
+    print("Saving the model...")
+    with open(model_save_path, "wb") as f:
+        pickle.dump(rfc_model, f)
+    print(f"Model saved to: {model_save_path}")
+
+
+def main(args):
+    task = args.task
+    if task == "train":
+        model_save_path = args.model_save_path
+        train_and_save_final_model(model_save_path=model_save_path)
+    elif task == "evaluate":
+        fraction_test_data_in_train = args.fraction
+        evaluate_models(fraction_test_data_in_train)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Train and evaluate models")
+    parser.add_argument(
+        "--task",
+        type=str,
+        choices=["train", "evaluate"],
+        required=True,
+        help="Whether to train and save the best model or evaluate all the models.",
+    )
+    parser.add_argument(
+        "--fraction",
+        type=float,
+        default=0.1,
+        help="Fraction of test data in train dataset",
+    )
+    parser.add_argument(
+        "--model_save_path",
+        type=str,
+        default="final_model.pkl",
+        help="Path to save the final model",
+    )
+    args = parser.parse_args()
+    main(args)

requirements.txt

@@ -0,0 +1,24 @@
+numpy==1.26.2
+pandas==2.1.3
+pypdf==3.17.1
+pytesseract==0.3.10
+pdf2image==1.16.3
+pdfminer.six==20221105
+pdfplumber==0.10.3
+Pillow==10.1.0
+PyPDF2==3.0.1
+pypdfium2==4.24.0
+pytesseract==0.3.10
+requests==2.31.0
+torch==2.1.1
+transformers==4.35.2
+datasets==2.15.0
+optuna==3.4.0
+requests==2.31.0
+scikit-learn==1.3.2
+scipy==1.11.4
+torchmetrics==1.2.1
+tqdm==4.66.1
+tokenizers==0.15.0
+xgboost==2.0.2
+gradio

torch_train.py

@@ -0,0 +1,543 @@
+import torch
+import numpy as np
+
+
+class TorchTrain:
+    """A class for training a model in PyTorch.
+
+    Parameters
+    -----------
+        model (torch.nn.Module): The PyTorch model to train.
+        optimizer (torch.optim.Optimizer): The optimizer to use for training.
+        loss_function (callable): The loss function to use for training.
+        metrics (dict or callable, optional): The metrics to evaluate during training.
+            If a dictionary, the keys are the metric names and the values are functions that
+            take in `yhat` and `y` and return a metric value. If a callable, it should take
+            in `yhat` and `y` and return a metric value. Defaults to None.
+
+    Attributes
+    -----------
+        DEVICE (torch.device): The device to use for training (cuda if available, cpu otherwise).
+        model (torch.nn.Module): The PyTorch model being trained.
+        optimizer (torch.optim.Optimizer): The optimizer being used for training.
+        loss_function (callable): The loss function being used for training.
+        metrics (dict or callable): The metrics being evaluated during training.
+        metrics_evaluated (dict): The metrics evaluated during training.
+        train_loss (float): The average training loss.
+        test_loss (float): The average test loss.
+        train_iteration (int): The number of training iterations.
+        test_iteration (int): The number of test iterations.
+        train_metrics (dict): The metrics evaluated on the training data.
+        test_metrics (dict): The metrics evaluated on the test data.
+    """
+
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def __init__(
+        self,
+        model,
+        optimizer,
+        loss_function,
+        metrics=None,
+        scheduler=None,
+        task_type="classification",
+    ) -> None:
+        """Initialize the TorchTrain object.
+
+        Parameters
+        -----------
+        model : torch.nn.Module
+            The PyTorch model to train.
+        optimizer : torch.optim.Optimizer
+            The optimizer to use for training.
+        loss_function : callable
+            The loss function to use for training.
+        metrics : dict or callable, optional
+            The metrics to evaluate during training. If a dictionary, the keys are the metric names
+            and the values are functions that take in `yhat` and `y` and return a metric value.
+            If a callable, it should take in `yhat` and `y` and return a metric value. Defaults to None.
+        scheduler : torch.optim.lr_scheduler, optional
+            The learning rate scheduler to use for training. Defaults to None.
+        """
+        self.model = model
+        self.model.to(self.DEVICE)
+        self.optimizer = optimizer
+        self.loss_function = loss_function
+        self.metrics = self.__preprocess_metrics(metrics)
+        self.scheduler = scheduler
+        self.metrics_evaluated = {}
+        self.train_loss = 0
+        self.test_loss = 0
+        self.train_iteration = 0
+        self.test_iteration = 0
+        self.train_metrics = {}
+        self.test_metrics = {}
+        self.history = {}
+        self.train_loss_all = []
+        self.test_loss_all = []
+        self.train_metrics_all = []
+        self.test_metrics_all = []
+        self.__train_scaled = False
+        self.__test_scaled = False
+        self.task_type = task_type
+
+    def __preprocess_metrics(self, metrics):
+        """Preprocesses the given metrics"""
+        if metrics is None:
+            return {}
+        if isinstance(metrics, dict):
+            return {key.title(): value for key, value in metrics.items()}
+        else:
+            raise TypeError(
+                "Metrics should be a dictionary of metrics or a function which takes yhat, y"
+            )
+
+    def __scale_matrices(self, loss, metrics, type="train"):
+        """Scales the loss and metrics
+
+        Parameters
+        -----------
+        loss : float
+            The loss to scale
+        metrics : dict
+            The metrics to scale
+        type : str, optional
+            The type of scaling to do, either "train" or "test", by default "train"
+
+        Returns
+        --------
+        loss : float
+            The scaled loss
+        metrics : dict
+            The scaled metrics
+        """
+        if type == "train" and not self.__train_scaled:
+            scale = self.train_iteration
+            self.__train_scaled = True
+        elif type == "test" and not self.__test_scaled:
+            scale = self.test_iteration
+            self.__test_scaled = True
+        else:
+            return loss, metrics
+        loss /= scale
+        for key in metrics:
+            metrics[key] /= scale
+        return loss, metrics
+
+    def __reset_counters(self):
+        """Resets all the counters and loss objects for a new epoch"""
+        self.train_loss, self.train_metrics = self.__scale_matrices(
+            self.train_loss, self.train_metrics, type="train"
+        )
+
+        self.test_loss, self.test_metrics = self.__scale_matrices(
+            self.test_loss, self.test_metrics, type="test"
+        )
+
+        self.train_loss_all.append(self.train_loss)
+        self.train_loss = 0
+
+        self.test_loss_all.append(self.test_loss)
+        self.test_loss = 0
+
+        self.train_iteration = 0
+        self.test_iteration = 0
+
+        self.train_metrics_all.append(self.train_metrics)
+        self.train_metrics = {}
+
+        self.test_metrics_all.append(self.test_metrics)
+        self.test_metrics = {}
+        self.__train_scaled = False
+        self.__test_scaled = False
+
+    @property
+    def loss(self):
+        """Returns the training loss"""
+        return self.train_loss_all[-1]
+
+    def __create_history(self):
+        """Creates the history dictionary"""
+        history = {
+            "train_loss": self.train_loss_all,
+            "val_loss": self.test_loss_all,
+        }
+        for key, value in self.metrics.items():
+            history[f"train_{key.lower()}"] = []
+            history[f"val_{key.lower()}"] = []
+
+        for item in self.train_metrics_all:
+            for key, value in item.items():
+                history[f"train_{key.lower()}"].append(value)
+
+        for item in self.test_metrics_all:
+            for key, value in item.items():
+                history[f"val_{key.lower()}"].append(value)
+        return history
+
+    def __parse_val(self, val):
+        """Parses the given value to a float"""
+        if isinstance(val, torch.Tensor):
+            val = val.item()
+        elif isinstance(val, np.ndarray):
+            val = float(val)
+        elif isinstance(val, (int, float)):
+            pass
+        else:
+            raise TypeError(
+                f"The given Metric function should return a tensor, numpy array, int, or float.\n\
+                    Got {type(val)}"
+            )
+        return val
+
+    def _train_step(self, x, y):
+        """Perform a single training step.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            The input tensor.
+        y : torch.Tensor
+            The target tensor.
+
+        Returns
+        -------
+        tuple
+            A tuple containing the loss and the predicted output tensor.
+        """
+        self.model.train()
+        yhat = self.model(x)
+        l = self.loss_function(yhat, y)
+        self.optimizer.zero_grad()
+        l.backward()
+        self.optimizer.step()
+        self.train_iteration += 1
+        return l.item(), yhat
+
+    def _test_step(self, x, y):
+        """Perform a single testing step.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            The input tensor.
+        y : torch.Tensor
+            The target tensor.
+
+        Returns
+        -------
+        tuple
+            A tuple containing the loss and the predicted output tensor.
+        """
+        self.model.eval()
+        with torch.inference_mode():
+            yhat = self.model(x)
+            l = self.loss_function(yhat, y)
+            self.test_iteration += 1
+        return l.item(), yhat
+
+    def predict(self, x):
+        """Make predictions on a batch of data.
+
+        Parameters
+        ----------
+        x : torch.Tensor
+            The input tensor.
+
+        Returns
+        -------
+        torch.Tensor
+            The predicted output tensor.
+        """
+        self.model.eval()
+        yhat = self.model(x)
+        if self.task_type == "classification":
+            if len(yhat.shape) == 1:
+                # round
+                yhat = torch.round(yhat)
+                yhat = yhat.unsqueeze(1)
+            else:
+                yhat = torch.argmax(yhat, dim=1)
+
+        return yhat
+
+    def __calculate_metrics(self, yhat, y):
+        """Calculate the metrics for a batch of data.
+
+        Parameters
+        ----------
+        yhat : torch.Tensor
+            The predicted output tensor.
+        y : torch.Tensor
+            The target tensor.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the values of the metrics.
+        """
+        metrics = {}
+        for key, metric in self.metrics.items():
+            val = metric(yhat, y)
+            if isinstance(val, torch.Tensor):
+                val = val.item()
+            elif isinstance(val, np.ndarray):
+                val = float(val)
+            elif isinstance(val, (int, float)):
+                pass
+            else:
+                raise TypeError(
+                    f"Metric {key} should return a tensor, numpy array, int, or float"
+                )
+            metrics[key] = val
+        self.metrics_evaluated = metrics
+        return metrics
+
+    def __progress_bar(self, cur_iter, all_iter):
+        """Creates a progress bar showing the progress of the current batch.
+
+        Parameters
+        ----------
+        cur_iter : int
+            The current batch number.
+        all_iter : int
+            The total number of batches.
+
+        Returns
+        -------
+        str
+            The progress bar, in the form of "10/100[====----]".
+        """
+        len_progress_bar = 20
+        progress = int((cur_iter + 1) / all_iter * len_progress_bar)
+        progress_bar = "=" * progress + "-" * (len_progress_bar - progress)
+        return f"[{progress_bar}]"
+
+    def progress(self, cur_iter, all_iter, loss, metrics, on="train"):
+        """Prints a progress bar showing the progress of the current batch.
+
+        Parameters
+        ----------
+        cur_iter : int
+            The current batch number.
+        all_iter : int
+            The total number of batches.
+        loss : float
+            The current loss. Should be averaged over all batches.
+        metrics : dict
+            The metrics evaluated on the current batch.
+        on : str, optional
+            Whether the progress bar is for the training or testing data. Defaults to "train".
+
+        Returns
+        -------
+        str
+            The progress bar, in the form of "10/100[====----]".
+
+        Notes
+        -----
+        The progress bar shows the progress of the current batch as a bar of equal signs ("=") and
+        hyphens ("-"). The length of the bar is fixed at 20 characters. The current batch number
+        and total number of batches are displayed at the beginning of the progress bar. The current
+        loss and any metrics evaluated on the current batch are displayed at the end of the progress
+        bar.
+        """
+        # len_progress_bar = 20
+        # progress = int((cur_iter + 1) / all_iter * len_progress_bar)
+        # progress_bar = "=" * progress + "-" * (len_progress_bar - progress)
+        progress_bar = self.__progress_bar(cur_iter=cur_iter, all_iter=all_iter)
+
+        if on.lower() == "train":
+            iteration = self.train_iteration
+            prefix = f"Epoch {(self.current_epoch+1):2d}/{self.epochs:2d} Batch "
+        else:
+            iteration = self.test_iteration
+            prefix = "Epoch "
+
+        text = f"{prefix}{cur_iter:>4d}/{all_iter:>4d}{progress_bar} {on.title()} loss: {loss/iteration:.4f}"
+        for metric_name, metric_value in metrics.items():
+            text += f" | {on.title()} {metric_name}: {metric_value/iteration:.4f}"
+
+        return text
+
+    def update_metrics(self, cur_metrics, new_metrics):
+        """Update the metrics with the values for a new batch of data.
+
+        Parameters
+        ----------
+        cur_metrics : dict
+            The current values of the metrics.
+        new_metrics : dict
+            The values of the metrics for a new batch of data.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the updated values of the metrics.
+        """
+        for key, value in new_metrics.items():
+            if key not in cur_metrics:
+                cur_metrics[key] = value
+            else:
+                cur_metrics[key] += value
+        return cur_metrics
+
+    def fit(
+        self,
+        train_loader,
+        validation_data_loader=None,
+        epochs=1,
+        verbose=True,
+        train_steps_per_epoch=None,
+        validation_steps_per_epoch=None,
+    ):
+        """Fit the PyTorch model.
+
+        Parameters
+        ----------
+        train_loader : torch.utils.data.DataLoader
+            The data loader for the training data.
+        validation_data_loader : torch.utils.data.DataLoader, optional
+            The data loader for the test data. Defaults to None.
+        epochs : int, optional
+            The number of epochs to train for. Defaults to 1.
+        verbose : bool, optional
+            Whether to print the training progress during training. Defaults to True.
+        train_steps_per_epoch : int, optional
+            The number of batches to train on per epoch. Defaults to None.
+        validation_steps_per_epoch : int, optional
+            The number of batches to test on per epoch. Defaults to None.
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> model = MyModel()
+        >>> optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+        >>> loss_function = nn.CrossEntropyLoss()
+        >>> scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9)
+        >>> train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
+        >>> validation_data_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
+        >>> trainer = TorchTrain(model, optimizer, loss_function, scheduler=scheduler)
+        >>> trainer.fit(train_loader, validation_data_loader=validation_data_loader, epochs=10, verbose=True)
+        """
+        self.epochs = epochs
+        if train_steps_per_epoch is None:
+            train_steps_per_epoch = len(train_loader)
+        if validation_data_loader is not None:
+            if validation_steps_per_epoch is None:
+                validation_steps_per_epoch = len(validation_data_loader)
+
+        for epoch in range(epochs):
+            self.current_epoch = epoch
+            for i, (x, y) in enumerate(train_loader):
+                x = x.to(self.DEVICE)
+                if isinstance(y, list) or isinstance(y, tuple):
+                    y = [y_.to(self.DEVICE) for y_ in y]
+                else:
+                    y = y.to(self.DEVICE)
+
+                train_loss, yhat = self._train_step(x, y)
+                self.train_loss += train_loss
+                metrics = self.__calculate_metrics(yhat, y)
+                self.train_metrics = self.update_metrics(self.train_metrics, metrics)
+
+                b_progress = self.progress(
+                    i + 1,
+                    train_steps_per_epoch,
+                    self.train_loss,
+                    self.train_metrics,
+                    on="train",
+                )
+                if i == train_steps_per_epoch - 1:
+                    print(b_progress)
+                    break
+                else:
+                    if verbose:
+                        print(b_progress, end="\r")
+            if validation_data_loader is not None:
+                for i, (x, y) in enumerate(validation_data_loader):
+                    x = x.to(self.DEVICE)
+                    if isinstance(y, list) or isinstance(y, tuple):
+                        y = [y_.to(self.DEVICE) for y_ in y]
+                    else:
+                        y = y.to(self.DEVICE)
+                    test_loss, yhat = self._test_step(x, y)
+                    self.test_loss += test_loss
+                    metrics = self.__calculate_metrics(yhat, y)
+                    self.test_metrics = self.update_metrics(self.test_metrics, metrics)
+                    if i == validation_steps_per_epoch - 1:
+                        break
+                test_progress = self.progress(
+                    epoch + 1,
+                    epochs,
+                    self.test_loss,
+                    self.test_metrics,
+                    on="test",
+                )
+                print(test_progress)
+            self.__reset_counters()
+            if self.scheduler is not None:
+                self.scheduler.step()
+            if verbose and self.scheduler is not None:
+                print(f"New Learning rate: {self.scheduler.get_last_lr()[0]:.6f}")
+
+        return self.__create_history()
+
+    def save(self, path):
+        """Save the model to a file.
+
+        Parameters
+        ----------
+        path : str
+            The path to the file to save the model to.
+        """
+        torch.save(self.model.state_dict(), path)
+
+    def load(self, path):
+        """Load the model from a file.
+
+        Parameters
+        ----------
+        path : str
+            The path to the file to load the model from.
+        """
+        self.model.load_state_dict(torch.load(path))
+
+    def evaluate(self, data_loader, metric):
+        """Evaluate the model on a data loader and the given metric.
+
+        Parameters
+        ----------
+        data_loader : torch.utils.data.DataLoader
+            The data loader to evaluate the model on.
+        metric : function
+            The metric to evaluate the model with.
+
+        Returns
+        -------
+        float
+            The score of the model on the given metric.
+        """
+        running_score = 0
+        data_length = len(data_loader)
+        for i, (x, y) in enumerate(data_loader):
+            progress_bar = self.__progress_bar(i, data_length)
+            x = x.to(self.DEVICE)
+            if isinstance(y, list) or isinstance(y, tuple):
+                y = [y_.to(self.DEVICE) for y_ in y]
+            else:
+                y = y.to(self.DEVICE)
+
+            yhat = self.model(x)
+            yhat = torch.round(yhat)
+            score = metric(y, yhat)
+            score = self.__parse_val(score)
+            running_score += score
+
+            progress_bar = f"{i+1}/{data_length}" + progress_bar
+            progress_bar += f" Score: {(running_score/(i+1)):4f}"
+            print(progress_bar, end="\r")
+        return running_score / (len(data_loader))

utilities.py

@@ -0,0 +1,481 @@
+import PyPDF2
+from pdfminer.high_level import extract_pages
+from pdfminer.layout import LTTextContainer, LTFigure
+import pdfplumber
+from pdf2image import convert_from_bytes
+
+import pytesseract
+import logging
+import requests
+from io import BytesIO
+
+import signal
+import time
+import functools
+
+
+import time
+import signal
+
+
+class ModuleException(Exception):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+
+class TimeoutError(ModuleException):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+
+class BadUrlException(ModuleException):
+    """Raised when the url is not valid"""
+
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+def timeout(seconds_before_timeout):
+    def wrapper_wrapper(func):
+        def handler(signum, frame):
+            raise TimeoutError()
+
+        @functools.wraps(func)
+        def wrapper_function(*args, **kwargs):
+            old = signal.signal(signal.SIGALRM, handler)
+            old_time_left = signal.alarm(seconds_before_timeout)
+            if (
+                0 < old_time_left < second_before_timeout
+            ):  # never lengthen existing timer
+                signal.alarm(old_time_left)
+            start_time = time.time()
+            try:
+                result = func(*args, **kwargs)
+            finally:
+                if old_time_left > 0:  # deduct f's run time from the saved timer
+                    old_time_left -= time.time() - start_time
+                signal.signal(signal.SIGALRM, old)
+                signal.alarm(old_time_left)
+            return result
+
+        return wrapper_function
+
+    return wrapper_wrapper
+
+
+def get_simple_logger(name, level="info"):
+    """Creates a simple loger that outputs to stdout"""
+    level_to_int_map = {
+        "debug": logging.DEBUG,
+        "info": logging.INFO,
+        "warning": logging.WARNING,
+        "error": logging.ERROR,
+        "critical": logging.CRITICAL,
+    }
+    if isinstance(level, str):
+        level = level_to_int_map[level.lower()]
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    handler = logging.StreamHandler()
+    handler.setLevel(level)
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger
+
+
+class PDFExtractor:
+    """A class to extract pdf information"""
+
+    def __init__(
+        self,
+        file_path,
+        min_characters=5,
+        maximum_pages=3,
+        is_url=True,
+    ) -> None:
+        """A class that can be used to extract pdf information from a file path or url
+
+        Parameters
+        ----------
+        file_path : str
+            The path to the file or the url
+        min_characters : int, optional
+            The minimum number of characters that a text needs to have to be considered a relevant text, by default 5
+        maximum_pages : int, optional
+            The maximum number of pages that the pdf can have, by default 5
+        is_url : bool, optional
+            Whether the file_path is a url or not, by default True
+
+        Raises
+        ------
+        ValueError
+            If the url raises a status code other than 200
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> extractor = PDFExtractor(file_path="file_path", min_characters=5, maximum_pages=5, is_url=False)
+        >>> extractor.extract_pages()
+        """
+        self.file_path = file_path
+        self.min_characters = min_characters
+        self.maximum_pages = maximum_pages
+        self.logger = get_simple_logger(name="pdf_extractor", level="info")
+        try:
+            self.byte_file = self._create_byte_object(self.file_path, is_url)
+        except Exception as e:
+            self.logger.error(e)
+            raise BadUrlException(str(e))
+        # PyPDF2 object
+        self.pypdf_object = PyPDF2.PdfReader(self.byte_file)
+        self.pdf_plumber_object = pdfplumber.open(self.byte_file)
+        # Pages from pdfminer
+        self.pdfminer_pages = extract_pages(self.byte_file)
+        self.page_contents = []
+        self.final_content = ""
+        self.one_page_contents = {
+            "contents": [],
+            "images": [],
+            "tables": [],
+        }
+
+    @timeout(120)
+    def _create_byte_object(self, path, is_url):
+        """Creates the byte file based on if it is url or not"""
+        if is_url:
+            res = requests.get(path)
+            if res.status_code == 200:
+                byte_file = BytesIO(res.content)
+            else:
+                raise BadUrlException(f"The url raised status code: {res.status_code}")
+        else:
+            byte_file = open(path, "rb")
+
+        return byte_file
+
+    def __check_for_relevant_text(self, text):
+        """Checks if the text is a relevant text or not
+
+        Parameters
+        ----------
+        text : str
+            The text to be checked
+
+        Returns
+        -------
+        bool
+            True if the text is a relevant text, False otherwise
+        """
+        # Remove the line breaker from the text
+        text_ = text.replace("\n", "")
+        if len(text_) > self.min_characters:
+            self.logger.debug(f"Text: {text_} is a relevant text.")
+            return True
+        self.logger.debug(f"Text: {text_} is not a relevant text.")
+        return False
+
+    def _handle_text(self, component):
+        """Handles the extraction of textual information
+
+        Parameters
+        ----------
+        component : pdfplumber.page.Page
+            The page object to extract the text from
+
+        Returns
+        -------
+        bool
+            True if the text is a relevant text, False otherwise
+
+        """
+        text = component.get_text()
+        if self.__check_for_relevant_text(text):
+            self.one_page_contents["contents"].append(text)
+            return True
+        return False
+
+    def __table_converter(self, table):
+        """Converts table from the output given by pdf_plumnber to make it more readble
+
+        Parameters
+        ----------
+        table : list
+            The table to be converted
+
+        Returns
+        -------
+        str
+            The converted table as a string
+
+        Examples
+        --------
+        >>> table = [["Name", "Age"], ["John", "30"], ["Jane", "25"]]
+        >>> table_string = __table_converter(table)
+        >>> print(table_string)
+        |Name|Age|
+        |John|30|
+        |Jane|25|
+
+        >>> table = [["Name", "Age"], ["John", "30"], ["Jane", "25"], ["\n", "None"]]
+        >>> table_string = __table_converter(table)
+        >>> print(table_string)
+        |Name|Age|
+        |John|30|
+        |Jane|25|
+        |None|None|
+
+        >>> table = [["Name", "Age"], ["John", "30"], ["Jane", "25"], ["\n", "None"], ["\n", "None"]]
+        >>> table_string = __table_converter(table)
+        """
+        table_string = ""
+        # Iterate through each row of the table
+        for row_num in range(len(table)):
+            row = table[row_num]
+            # Remove the line breaker from the wrapted texts
+            cleaned_row = [
+                item.replace("\n", " ")
+                if item is not None and "\n" in item
+                else "None"
+                if item is None
+                else item
+                for item in row
+            ]
+            # Convert the table into a string
+            table_string += "|" + "|".join(cleaned_row) + "|" + "\n"
+        # Removing the last line break
+        table_string = table_string[:-1]
+        return table_string
+
+    def _handle_table(self, page_number):
+        """Handles the extraction of tabular information
+
+        Parameters
+        ----------
+        page_number : int
+            The page number to extract the table from
+
+        Returns
+        -------
+        None
+        """
+        page = self.pdf_plumber_object.pages[page_number]
+        try:
+            tables = page.extract_tables()
+        except:
+            tables = [
+                ["NA", "NA"],
+            ]
+        tables_final = [self.__table_converter(table) for table in tables]
+        self.one_page_contents["tables"] = tables_final
+
+    # Create a function to crop the image elements from PDFs
+
+    def __crop_image(self, element, page_number):
+        """Crops the pdf and creates a new pdf with only the cropped area. This will later be converted into image and then OCRed using pytesseract
+
+        Parameters
+        ----------
+        element : pdfminer.layout.LTTextContainer
+            The element to crop from the pdf
+        page_number : int
+            The page number to crop the element from
+
+        Returns
+        -------
+        bytes
+            The cropped pdf as a byte object
+        """
+        pypdf_page = self.pypdf_object.pages[page_number]
+        # Get the coordinates to crop the image from PDF
+        [image_left, image_top, image_right, image_bottom] = [
+            element.x0,
+            element.y0,
+            element.x1,
+            element.y1,
+        ]
+        # Crop the page using coordinates (left, bottom, right, top)
+        pypdf_page.mediabox.lower_left = (image_left, image_bottom)
+        pypdf_page.mediabox.upper_right = (image_right, image_top)
+        # Save the cropped page to a new PDF
+        cropped_pdf_writer = PyPDF2.PdfWriter()
+        cropped_pdf_writer.add_page(pypdf_page)
+        # convert to byte
+        cropped_pdf_stream = BytesIO()
+        cropped_pdf_writer.write(cropped_pdf_stream)
+        byte_object = cropped_pdf_stream.getvalue()
+        return byte_object
+
+    # Create a function to convert the PDF to images
+    def _convert_to_images(self, pdf_byte):
+        """Converts the pdf byte object to images
+
+        Parameters
+        ----------
+        pdf_byte : bytes
+            The pdf byte object to be converted
+
+        Returns
+        -------
+        PIL.Image
+            The converted image
+        """
+        images = convert_from_bytes(pdf_byte)
+        image = images[0]
+        return image
+
+    @timeout(20)
+    def _image_to_text(self, image):
+        """Extracts text from image using pytesseract
+
+        Parameters
+        ----------
+        image : PIL.Image
+            The image to extract text from
+
+        Returns
+        -------
+        str
+            The extracted text from the image
+
+        Examples
+        --------
+        >>> image = PIL.Image.open("image.jpg")
+        >>> text = _image_to_text(image)
+        >>> print(text)
+        DUMMY TEXT
+        """
+        text = pytesseract.image_to_string(image)
+        # text = "DUMMY TEXT"
+        self.logger.debug(f"Extracted {text} from the image.")
+        return text
+
+    def _handle_image(self, element, page_number):
+        """Handles the extraction of image information
+
+        Parameters
+        ----------
+        element : pdfminer.layout.LTFigure
+            The element to extract the image from
+        page_number : int
+            The page number to extract the image from
+
+        Returns
+        -------
+        bool
+            True if the image is a relevant image, False otherwise
+
+        Notes
+        -----
+        Extract the text from the image using pytesseract. Check if the text is a relevant text or not. If the text is a relevant text, add it to the one_page_contents dictionary with the key "images"
+        If the text is not a relevant text, do nothing
+        Return True if the image is a relevant image, False otherwise
+        If the image is a relevant image, add it to the one_page_contents dictionary with the key "images"
+        If the image is not a relevant image, do nothing
+        Return True if the image is a relevant image, False otherwise
+        """
+        cropped_pdf = self.__crop_image(element, page_number)
+        image = self._convert_to_images(pdf_byte=cropped_pdf)
+        extracted_text = self._image_to_text(image)
+        # try:
+        #     extracted_text = self._image_to_text(image)
+        # except TimeoutError:
+        #     self.logger.warning("Timeout encountered. Skipping it.")
+        #     return False
+        if self.__check_for_relevant_text(extracted_text):
+            self.one_page_contents["images"].append(extracted_text)
+            return True
+        return False
+
+    def extract_one_page(self, page_number, pdfminer_page):
+        """Extracts information from one page of the pdf
+
+        Parameters
+        ----------
+        page_number : int
+            The page number to extract the information from
+        pdfminer_page : pdfminer.layout.LTPage
+            The pdfminer page object to extract the information from
+
+        Returns
+        -------
+        None
+        """
+        self.one_page_contents = {
+            "contents": [],
+            "images": [],
+            "tables": [],
+        }
+        self._handle_table(page_number=page_number)
+        max_image_per_page = 2
+        image_number = 0
+        for element_number, element in enumerate(pdfminer_page._objs):
+            type_ = type(element)
+            self.logger.debug(
+                f"Handling Page: {page_number}, Element: {element_number} Type: {type_}"
+            )
+
+            if isinstance(element, LTTextContainer):
+                self._handle_text(element)
+
+            if isinstance(element, LTFigure) and image_number < max_image_per_page:
+                added = self._handle_image(
+                    element=element,
+                    page_number=page_number,
+                )
+                if added:
+                    image_number += 1
+        self.page_contents.append(self.one_page_contents)
+
+    def create_final_text_content(self):
+        """Creates the final text using the information extracted so far. The final text has all the textual information, image information and tabular information. This text directly can be used for machine learning."""
+        final_content = ""
+        for page_number, content in enumerate(self.page_contents):
+            final_content += f"PAGE {page_number}\n"
+            text_contents = content["contents"]
+            final_content += "\n".join(text_contents)
+            for i, image in enumerate(content["images"]):
+                final_content += f"IMAGE {i}\n{image.strip()}\nIMAGE {i} ENDS\n"
+
+            for i, table in enumerate(content["tables"]):
+                final_content += f"TABLE {i}\n{table.strip()}\nTABLE {i} ENDS\n"
+            final_content += f"PAGE {page_number} ENDS\n"
+        self.final_content = final_content
+        return final_content
+
+    def extract_pages(self):
+        """Extracts information from all the pages of the pdf. This is the final method to be used
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        str
+            The final text content of the pdf. This text can be directly used for machine learning.
+        """
+        pages = extract_pages(self.byte_file)
+        for page_number, page in enumerate(pages):
+            self.logger.info(f"Working on the page: {page_number}")
+            if page_number >= self.maximum_pages:
+                self.logger.info(f"Maximum page limit reached. Breaking...")
+                break
+            self.extract_one_page(page_number, page)
+
+        final_content = self.create_final_text_content()
+        return final_content
+
+    # def __del__(self):
+    #     # Make sure that the file is closed once the object is deleted
+    #     self.logger.debug("Closing open file and removing the temporary directory.")
+    #     self.byte_file.close()