pipeline added

.dvcignore

@@ -0,0 +1,3 @@
+# Add patterns of files dvc should ignore, which could improve
+# the performance. Learn more at
+# https://dvc.org/doc/user-guide/dvcignore

.gitignore

@@ -160,3 +160,5 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+artifacts/*
+model.h5/*

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11-slim
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code
+
+CMD ["streamlit", "run", "app.py"]

README.md

@@ -1 +1,111 @@
-# Kidney-disease-classification-mlops
+---
+title: Image To Text App
+emoji: 📹
+colorFrom: blue
+colorTo: red
+sdk: streamlit
+app_file: app.py
+pinned: false
+---
+
+
+
+# Kidney-disease-classification-mlops
+
+## Workflows
+
+1. Update config.yaml
+2. Update secrets.yaml [Optional]
+3. Update params.yaml
+4. Update the entity
+5. Update the configuration manager in src config
+6. Update the components
+7. Update the pipeline 
+8. Update the main.py
+9. Update the dvc.yaml
+10. app.py
+
+# How to run?
+### STEPS:
+
+Clone the repository
+
+```bash
+https://github.com/HAKIM-ML/
+Kidney-disease-classification-mlops
+```
+### STEP 01- Create a conda environment after opening the repository
+
+```bash
+conda create -n cnncls python=3.8 -y
+```
+
+```bash
+conda activate cnncls
+```
+
+
+### STEP 02- install the requirements
+```bash
+pip install -r requirements.txt
+```
+
+```bash
+# Finally run the following command
+python app.py
+```
+
+Now,
+```bash
+open up you local host and port
+```
+
+
+
+
+
+
+## MLflow
+
+- [Documentation](https://mlflow.org/docs/latest/index.html)
+
+
+##### cmd
+- mlflow ui
+
+### dagshub
+[dagshub](https://dagshub.com/)
+MLFLOW_TRACKING_URI = https://dagshub.com/azizulhakim8291/Kidney-disease-classification-mlops.mlflow
+
+
+python script.py
+
+import dagshub
+dagshub.init(repo_owner='azizulhakim8291', repo_name='Kidney-disease-classification-mlops', mlflow=True)
+
+import mlflow
+with mlflow.start_run():
+  mlflow.log_param('parameter name', 'value')
+  mlflow.log_metric('metric name', 1)
+
+### DVC cmd
+
+1. dvc init
+2. dvc repro
+3. dvc dag
+
+
+## About MLflow & DVC
+
+MLflow
+
+ - Its Production Grade
+ - Trace all of your expriements
+ - Logging & taging your model
+
+
+DVC 
+
+ - Its very lite weight for POC only
+ - lite weight expriements tracker
+ - It can perform Orchestration (Creating Pipelines)

app.py

@@ -0,0 +1,70 @@
+
+import streamlit as st
+import io
+from PIL import Image
+import os
+from cnnClassifier.pipeline.predict import Prediction
+
+st.set_page_config(page_title="Chicken Health Predictor", page_icon="🐔", layout="wide")
+
+st.title("🐔 Chicken Health Predictor")
+st.markdown("### Upload an image to predict if the chicken is healthy or has coccidiosis")
+
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+
+col1, col2 = st.columns(2)
+
+if uploaded_file is not None:
+    image = Image.open(uploaded_file)
+    col1.image(image, caption="Uploaded Image", use_column_width=True)
+    
+    # Save the uploaded file temporarily
+    temp_file = "temp_image.jpg"
+    image.save(temp_file)
+    
+    with st.spinner("Analyzing the image..."):
+        predictor = Prediction(temp_file)
+        prediction = predictor.predict()
+    
+    # Remove the temporary file
+    os.remove(temp_file)
+    
+    col2.markdown("## Prediction Result")
+    if prediction == "Normal":
+        col2.success(f"The chicken appears to be **{prediction}**! 🎉")
+        col2.markdown("Keep up the good care for your feathered friend!")
+    else:
+        col2.error(f"The kidney may have **{prediction}**. 😢")
+        col2.markdown("Please consult with a veterinarian for proper treatment.")
+    
+    
+
+st.sidebar.title("About")
+st.sidebar.info(
+    "This app uses a deep learning model to predict whether a chicken is healthy "
+    "or has coccidiosis based on an uploaded image. Always consult with a "
+    "veterinarian for accurate diagnosis and treatment."
+)
+
+st.sidebar.title("Instructions")
+st.sidebar.markdown(
+    """
+    1. Upload a clear image of a chicken.
+    2. Wait for the model to analyze the image.
+    3. View the prediction result and additional information.
+    """
+)
+
+st.markdown(
+    """
+    <style>
+    .reportview-container {
+        background: linear-gradient(to right, #FDFCFB, #E2D1C3);
+    }
+    .sidebar .sidebar-content {
+        background: linear-gradient(to bottom, #FDFCFB, #E2D1C3);
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)

config/config.yaml

@@ -0,0 +1,21 @@
+atifacts_root : artifacts
+
+data_ingestion:
+  root_dir : artifacts/data_ingestion
+  source_URL : https://drive.google.com/file/d/1vlhZ5c7abUKF8xXERIw6m9Te8fW7ohw3/view?usp=sharing
+  local_data_file : artifacts/data_ingestion/data.zip
+  unzip_dir : artifacts/data_ingestion/unzip
+
+
+prepare_base_model:
+  root_dir: artifacts/prepare_base_model
+  base_model_path: artifacts/prepare_base_model/base_model.h5
+  updated_base_model_path: artifacts/prepare_base_model/base_model_updated.h5
+
+  
+
+training:
+  root_dir: artifacts/training
+  trained_model_path : artifacts/training/model.h5
+
+  

dvc.lock

@@ -0,0 +1,113 @@
+schema: '2.0'
+stages:
+  data_ingestion:
+    cmd: python src/cnnClassifier/pipeline/stage_01_data_ingestion.py
+    deps:
+    - path: config/config.yaml
+      hash: md5
+      md5: 18c5d166940398f449d80f3bf7ceba78
+      size: 601
+    - path: src/cnnClassifier/pipeline/stage_01_data_ingestion.py
+      hash: md5
+      md5: 9ab8c5d8d045a810fdc294c23dba44a2
+      size: 906
+    outs:
+    - path: artifacts/data_ingestion/unzip/kidney-ct-scan-image
+      hash: md5
+      md5: 33ed59dbe5dec8ce2bb8e489b55203e4.dir
+      size: 58936381
+      nfiles: 465
+  prepare_base_model:
+    cmd: python src/cnnClassifier/pipeline/stage_02_prepare_base_model.py
+    deps:
+    - path: config/config.yaml
+      hash: md5
+      md5: 18c5d166940398f449d80f3bf7ceba78
+      size: 601
+    - path: src/cnnClassifier/pipeline/stage_02_prepare_base_model.py
+      hash: md5
+      md5: e8e39a301f4b90d1b4f2c86acc66ef32
+      size: 999
+    params:
+      params.yaml:
+        CLASSES: 2
+        IMAGE_SIZE:
+        - 224
+        - 224
+        - 3
+        INCLUDE_TOP: false
+        LEARNING_RATE: 0.009
+        WEIGHTS: imagenet
+    outs:
+    - path: artifacts/prepare_base_model
+      hash: md5
+      md5: 186cffa6925a8727cbd781402a5b2d91.dir
+      size: 118054560
+      nfiles: 2
+  training:
+    cmd: python src/cnnClassifier/pipeline/stage_03_train_model.py
+    deps:
+    - path: artifacts/data_ingestion/unzip/kidney-ct-scan-image
+      hash: md5
+      md5: 33ed59dbe5dec8ce2bb8e489b55203e4.dir
+      size: 58936381
+      nfiles: 465
+    - path: artifacts/prepare_base_model
+      hash: md5
+      md5: 186cffa6925a8727cbd781402a5b2d91.dir
+      size: 118054560
+      nfiles: 2
+    - path: config/config.yaml
+      hash: md5
+      md5: 18c5d166940398f449d80f3bf7ceba78
+      size: 601
+    - path: src/cnnClassifier/pipeline/stage_03_train_model.py
+      hash: md5
+      md5: 3ef39a6e5a0d665c7c48877e098f3c82
+      size: 919
+    params:
+      params.yaml:
+        AUGMENTATION: true
+        BATCH_SIZE: 32
+        EPOCHS: 2
+        IMAGE_SIZE:
+        - 224
+        - 224
+        - 3
+    outs:
+    - path: artifacts/training/model.h5
+      hash: md5
+      md5: b860a0e1daa2296bf1ab06265a233dae
+      size: 59337520
+  evaluation:
+    cmd: python src/cnnClassifier/pipeline/stage_04_evaluation.py
+    deps:
+    - path: artifacts/data_ingestion/unzip/kidney-ct-scan-image
+      hash: md5
+      md5: 33ed59dbe5dec8ce2bb8e489b55203e4.dir
+      size: 58936381
+      nfiles: 465
+    - path: artifacts/training/model.h5
+      hash: md5
+      md5: b860a0e1daa2296bf1ab06265a233dae
+      size: 59337520
+    - path: config/config.yaml
+      hash: md5
+      md5: 18c5d166940398f449d80f3bf7ceba78
+      size: 601
+    - path: src/cnnClassifier/pipeline/stage_04_evaluation.py
+      hash: md5
+      md5: ef1e7f821e740d1e4a9d51a4bf724e68
+      size: 888
+    params:
+      params.yaml:
+        BATCH_SIZE: 32
+        IMAGE_SIZE:
+        - 224
+        - 224
+        - 3
+    outs:
+    - path: scores.json
+      hash: md5
+      md5: 8930e55b40b3d3c2866622648a461a1c
+      size: 72

dvc.yaml

@@ -0,0 +1,51 @@
+stages:
+  data_ingestion:
+    cmd: python src/cnnClassifier/pipeline/stage_01_data_ingestion.py
+    deps:
+      - src/cnnClassifier/pipeline/stage_01_data_ingestion.py
+      - config/config.yaml
+    outs:
+      - artifacts/data_ingestion/unzip/kidney-ct-scan-image
+
+  prepare_base_model:
+    cmd: python src/cnnClassifier/pipeline/stage_02_prepare_base_model.py
+    deps:
+      - src/cnnClassifier/pipeline/stage_02_prepare_base_model.py
+      - config/config.yaml
+    params:
+      - IMAGE_SIZE
+      - INCLUDE_TOP
+      - CLASSES
+      - WEIGHTS
+      - LEARNING_RATE
+    outs:
+      - artifacts/prepare_base_model
+
+  training:
+    cmd: python src/cnnClassifier/pipeline/stage_03_train_model.py
+    deps:
+      - src/cnnClassifier/pipeline/stage_03_train_model.py
+      - config/config.yaml
+      - artifacts/data_ingestion/unzip/kidney-ct-scan-image
+      - artifacts/prepare_base_model
+    params:
+      - IMAGE_SIZE
+      - EPOCHS
+      - BATCH_SIZE
+      - AUGMENTATION
+    outs:
+      - artifacts/training/model.h5
+
+  evaluation:
+    cmd: python src/cnnClassifier/pipeline/stage_04_evaluation.py
+    deps:
+      - src/cnnClassifier/pipeline/stage_04_evaluation.py
+      - config/config.yaml
+      - artifacts/data_ingestion/unzip/kidney-ct-scan-image
+      - artifacts/training/model.h5
+    params:
+      - IMAGE_SIZE
+      - BATCH_SIZE
+    metrics:
+    - scores.json:
+        cache: false

main.py

@@ -0,0 +1,51 @@
+from cnnClassifier import logger
+from cnnClassifier.pipeline.stage_01_data_ingestion import DataIngestionTrainingPipeline
+from cnnClassifier.pipeline.stage_02_prepare_base_model import PrepareBaseModelTrainingPipeline
+from cnnClassifier.pipeline.stage_03_train_model import ModelTrainingPipeline
+from cnnClassifier.pipeline.stage_04_evaluation import EvaluationTrainingPipeline
+
+STAGE_NAME = "Data Ingestion stage"
+try:
+   logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<") 
+   data_ingestion = DataIngestionTrainingPipeline()
+   data_ingestion.main()
+   logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+except Exception as e:
+        logger.exception(e)
+        raise e
+     
+STAGE_NAME = "Prepare Base Model  stage"
+try:
+   logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<") 
+   prepare_base_model = PrepareBaseModelTrainingPipeline()
+   prepare_base_model.main()
+   logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+except Exception as e:
+        logger.exception(e)
+        raise e
+     
+     
+STAGE_NAME = "Model Training"
+
+try:
+   logger.info(f"*******************")
+   logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<")
+   obj = ModelTrainingPipeline()
+   obj.main()
+   logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+except Exception as e:
+   logger.exception(e)
+   raise e
+
+
+STAGE_NAME = "Evaluation"
+
+try:
+   logger.info(f"*******************")
+   logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<")
+   obj = EvaluationTrainingPipeline()
+   obj.main()
+   logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+except Exception as e:
+   logger.exception(e)
+   raise e

params.yaml

@@ -0,0 +1,8 @@
+AUGMENTATION : TRUE
+IMAGE_SIZE: [224,224,3]
+EPOCHS : 2
+BATCH_SIZE : 32
+LEARNING_RATE : 0.009
+CLASSES : 2
+WEIGHTS : imagenet
+INCLUDE_TOP : False

requirements.txt

@@ -0,0 +1,18 @@
+tensorflow==2.12.0
+pandas 
+dvc
+mlflow==2.2.2
+notebook
+numpy
+matplotlib
+seaborn
+python-box==6.0.2
+pyYAML
+tqdm
+ensure==1.0.2
+joblib
+types-PyYAML
+scipy
+Flask
+Flask-Cors
+gdown

research/01_data_ingestion.ipynb

@@ -0,0 +1,177 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.chdir('../')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# entity\n",
+    "from dataclasses import dataclass\n",
+    "from pathlib import Path\n",
+    "\n",
+    "@dataclass(frozen=True)\n",
+    "class DataIngestionConfig:\n",
+    "    root_dir: Path\n",
+    "    source_URL: str\n",
+    "    local_data_file: Path\n",
+    "    unzip_dir: Path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cnnClassifier.utils.common import read_yaml, create_directories\n",
+    "from cnnClassifier.constant import *\n",
+    "# Configuration\n",
+    "class ConfigurationManager:\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        config_filepath = CONFIG_FILE_PATH,\n",
+    "        params_filepath = PARAMS_FILE_PATH\n",
+    "    ):\n",
+    "        self.config = read_yaml(config_filepath)\n",
+    "        self.params = read_yaml(params_filepath)\n",
+    "        \n",
+    "        create_directories([self.config.atifacts_root])\n",
+    "        \n",
+    "        \n",
+    "        \n",
+    "    def get_data_ingestion_config(self) -> DataIngestionConfig:\n",
+    "        config = self.config.data_ingestion\n",
+    "        create_directories([config.root_dir])\n",
+    "        \n",
+    "        data_ingestion_config = DataIngestionConfig(\n",
+    "            root_dir=config.root_dir,\n",
+    "            source_URL=config.source_URL,\n",
+    "            local_data_file=config.local_data_file,\n",
+    "            unzip_dir=config.unzip_dir\n",
+    "        )\n",
+    "        \n",
+    "        return data_ingestion_config\n",
+    "    \n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# components\n",
+    "\n",
+    "import os\n",
+    "import zipfile\n",
+    "import gdown\n",
+    "from cnnClassifier import logger\n",
+    "from cnnClassifier.utils.common import get_size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class DataIngestion:\n",
+    "    def __init__(self, config: DataIngestionConfig):\n",
+    "        self.config = config\n",
+    "        \n",
+    "    def download_file(self) -> str:\n",
+    "        try:\n",
+    "            dataset_url = self.config.source_URL\n",
+    "            zip_download_dir = self.config.local_data_file\n",
+    "            os.makedirs('artifacts/datasets', exist_ok=True)\n",
+    "            logger.info(f'Downloading data from {dataset_url} into {zip_download_dir}')\n",
+    "            \n",
+    "            file_id = dataset_url.split('/')[-2]\n",
+    "            prefix = 'https://drive.google.com/uc?/export=download&id='\n",
+    "            gdown.download(prefix + file_id, zip_download_dir)\n",
+    "            logger.info(f'Downloaded data from {dataset_url} into {zip_download_dir}')\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            raise e\n",
+    "        \n",
+    "        \n",
+    "        \n",
+    "    def extract_zip_file(self):\n",
+    "        \"\"\"\n",
+    "        zip_file_path: str\n",
+    "        Extracts the zip file into the data directory\n",
+    "        Function returns None\n",
+    "        \"\"\"\n",
+    "        unzip_path = self.config.unzip_dir\n",
+    "        os.makedirs(unzip_path, exist_ok=True)\n",
+    "        with zipfile.ZipFile(self.config.local_data_file, 'r') as zip_ref:\n",
+    "            zip_ref.extractall(unzip_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  5%|▍         | 2.62M/57.7M [00:30<03:49, 240kB/s]"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    config = ConfigurationManager()\n",
+    "    data_ingestion_config = config.get_data_ingestion_config()\n",
+    "    data_ingestion = DataIngestion(config=data_ingestion_config)\n",
+    "    data_ingestion.download_file()\n",
+    "    data_ingestion.extrat_zip_file()\n",
+    "except Exception as e:\n",
+    "    raise e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

research/02_prepare_base_model.ipynb

@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.chdir('../')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from pathlib import Path\n",
+    "\n",
+    "\n",
+    "@dataclass(frozen=True)\n",
+    "class PrepareBaseModelConfig:\n",
+    "    root_dir: Path\n",
+    "    base_model_path: Path\n",
+    "    updated_base_model_path: Path\n",
+    "    params_image_size: list\n",
+    "    params_learning_rate: float\n",
+    "    params_include_top: bool\n",
+    "    params_weights: str\n",
+    "    params_classes: int"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cnnClassifier.utils.common import read_yaml, create_directories\n",
+    "from cnnClassifier.constant import *\n",
+    "# Configuration\n",
+    "class ConfigurationManager:\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        config_filepath = CONFIG_FILE_PATH,\n",
+    "        params_filepath = PARAMS_FILE_PATH):\n",
+    "\n",
+    "        self.config = read_yaml(config_filepath)\n",
+    "        self.params = read_yaml(params_filepath)\n",
+    "\n",
+    "        create_directories([self.config.atifacts_root])\n",
+    "\n",
+    "    \n",
+    "\n",
+    "    def get_prepare_base_model_config(self) -> PrepareBaseModelConfig:\n",
+    "        config = self.config.prepare_base_model\n",
+    "        \n",
+    "        create_directories([config.root_dir])\n",
+    "\n",
+    "        prepare_base_model_config = PrepareBaseModelConfig(\n",
+    "            root_dir=Path(config.root_dir),\n",
+    "            base_model_path=Path(config.base_model_path),\n",
+    "            updated_base_model_path=Path(config.updated_base_model_path),\n",
+    "            params_image_size=self.params.IMAGE_SIZE,\n",
+    "            params_learning_rate=self.params.LEARNING_RATE,\n",
+    "            params_include_top=self.params.INCLUDE_TOP,\n",
+    "            params_weights=self.params.WEIGHTS,\n",
+    "            params_classes=self.params.CLASSES\n",
+    "        )\n",
+    "\n",
+    "        return prepare_base_model_config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-07-30 03:19:34,344: WARNING: module_wrapper: From c:\\Users\\User\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n",
+      "]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import urllib.request as request\n",
+    "import tensorflow as tf\n",
+    "\n",
+    "class PrepareBaseModel:\n",
+    "    def __init__(self, config: PrepareBaseModelConfig):\n",
+    "        self.config = config\n",
+    "\n",
+    "    \n",
+    "    def get_base_model(self):\n",
+    "        self.model = tf.keras.applications.vgg16.VGG16(\n",
+    "            input_shape=self.config.params_image_size,\n",
+    "            weights=self.config.params_weights,\n",
+    "            include_top=self.config.params_include_top\n",
+    "        )\n",
+    "\n",
+    "        self.save_model(path=self.config.base_model_path, model=self.model)\n",
+    "\n",
+    "    \n",
+    "\n",
+    "    @staticmethod\n",
+    "    def _prepare_full_model(model, classes, freeze_all, freeze_till, learning_rate):\n",
+    "        if freeze_all:\n",
+    "            for layer in model.layers:\n",
+    "                model.trainable = False\n",
+    "        elif (freeze_till is not None) and (freeze_till > 0):\n",
+    "            for layer in model.layers[:-freeze_till]:\n",
+    "                model.trainable = False\n",
+    "\n",
+    "        flatten_in = tf.keras.layers.Flatten()(model.output)\n",
+    "        prediction = tf.keras.layers.Dense(\n",
+    "            units=classes,\n",
+    "            activation=\"softmax\"\n",
+    "        )(flatten_in)\n",
+    "\n",
+    "        full_model = tf.keras.models.Model(\n",
+    "            inputs=model.input,\n",
+    "            outputs=prediction\n",
+    "        )\n",
+    "\n",
+    "        full_model.compile(\n",
+    "            optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate),\n",
+    "            loss=tf.keras.losses.CategoricalCrossentropy(),\n",
+    "            metrics=[\"accuracy\"]\n",
+    "        )\n",
+    "\n",
+    "        full_model.summary()\n",
+    "        return full_model\n",
+    "    \n",
+    "    \n",
+    "    def update_base_model(self):\n",
+    "        self.full_model = self._prepare_full_model(\n",
+    "            model=self.model,\n",
+    "            classes=self.config.params_classes,\n",
+    "            freeze_all=True,\n",
+    "            freeze_till=None,\n",
+    "            learning_rate=self.config.params_learning_rate\n",
+    "        )\n",
+    "\n",
+    "        self.save_model(path=self.config.updated_base_model_path, model=self.full_model)\n",
+    "\n",
+    "    \n",
+    "        \n",
+    "    @staticmethod\n",
+    "    def save_model(path: Path, model: tf.keras.Model):\n",
+    "        model.save(path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-07-30 03:19:36,293: INFO: common: yaml file: config\\config.yaml loaded successfully]\n",
+      "[2024-07-30 03:19:36,296: INFO: common: yaml file: params.yaml loaded successfully]\n",
+      "[2024-07-30 03:19:36,298: INFO: common: Created directory  at: artifacts]\n",
+      "[2024-07-30 03:19:36,299: INFO: common: Created directory  at: artifacts/prepare_base_model]\n",
+      "[2024-07-30 03:19:36,531: WARNING: module_wrapper: From c:\\Users\\User\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\backend.py:1398: The name tf.executing_eagerly_outside_functions is deprecated. Please use tf.compat.v1.executing_eagerly_outside_functions instead.\n",
+      "]\n",
+      "[2024-07-30 03:19:36,660: WARNING: module_wrapper: From c:\\Users\\User\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\layers\\pooling\\max_pooling2d.py:161: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n",
+      "]\n",
+      "[2024-07-30 03:19:37,174: WARNING: saving_utils: Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.]\n",
+      "Model: \"model\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " input_1 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
+      "                                                                 \n",
+      " block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      \n",
+      "                                                                 \n",
+      " block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     \n",
+      "                                                                 \n",
+      " block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         \n",
+      "                                                                 \n",
+      " block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     \n",
+      "                                                                 \n",
+      " block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    \n",
+      "                                                                 \n",
+      " block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         \n",
+      "                                                                 \n",
+      " block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    \n",
+      "                                                                 \n",
+      " block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    \n",
+      "                                                                 \n",
+      " block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    \n",
+      "                                                                 \n",
+      " block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         \n",
+      "                                                                 \n",
+      " block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   \n",
+      "                                                                 \n",
+      " block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
+      "                                                                 \n",
+      " block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
+      "                                                                 \n",
+      " block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\User\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\engine\\training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
+      "  saving_api.save_model(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                                                 \n",
+      " block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
+      "                                                                 \n",
+      " block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
+      "                                                                 \n",
+      " block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
+      "                                                                 \n",
+      " block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         \n",
+      "                                                                 \n",
+      " flatten (Flatten)           (None, 25088)             0         \n",
+      "                                                                 \n",
+      " dense (Dense)               (None, 2)                 50178     \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 14764866 (56.32 MB)\n",
+      "Trainable params: 50178 (196.01 KB)\n",
+      "Non-trainable params: 14714688 (56.13 MB)\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    config = ConfigurationManager()\n",
+    "    prepare_base_model_config = config.get_prepare_base_model_config()\n",
+    "    prepare_base_model = PrepareBaseModel(config=prepare_base_model_config)\n",
+    "    prepare_base_model.get_base_model()\n",
+    "    prepare_base_model.update_base_model()\n",
+    "except Exception as e:\n",
+    "    raise e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

research/03_model_training.ipynb

@@ -0,0 +1,285 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.chdir('../')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'d:\\\\MLOps-Project\\\\Kidney-disease-classification-mlops'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from pathlib import Path\n",
+    "\n",
+    "@dataclass(frozen=True)\n",
+    "class TrainingConfig:\n",
+    "    root_dir : Path\n",
+    "    training_model_path : Path\n",
+    "    updata_base_model_path  :  Path\n",
+    "    training_data: Path\n",
+    "    params_epochs : int\n",
+    "    params_is_augmentation : bool\n",
+    "    params_batch_size : int\n",
+    "    params_image_size : list\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cnnClassifier.utils.common import read_yaml, create_directories\n",
+    "from cnnClassifier.constant import *\n",
+    "\n",
+    "from cnnClassifier.utils.common import read_yaml, create_directories\n",
+    "from cnnClassifier.constant import *\n",
+    "# Configuration\n",
+    "class ConfigurationManager:\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        config_filepath = CONFIG_FILE_PATH,\n",
+    "        params_filepath = PARAMS_FILE_PATH):\n",
+    "\n",
+    "        self.config = read_yaml(config_filepath)\n",
+    "        self.params = read_yaml(params_filepath)\n",
+    "\n",
+    "        create_directories([self.config.atifacts_root])\n",
+    "        \n",
+    "    def get_training_config(self) -> TrainingConfig:\n",
+    "        training =  self.config.training\n",
+    "        prepare_base_model =self.config.prepare_base_model\n",
+    "        params = self.params\n",
+    "        training_data = os.path.join(self.config.data_ingestion.unzip_dir, 'kidney-ct-scan-image') \n",
+    "        \n",
+    "        create_directories([\n",
+    "            Path(training.root_dir)\n",
+    "        ])\n",
+    "        \n",
+    "        training_config = TrainingConfig(\n",
+    "        root_dir= Path(training.root_dir),\n",
+    "        training_model_path=Path(training.trained_model_path),\n",
+    "        updata_base_model_path=Path(prepare_base_model.updated_base_model_path),\n",
+    "        training_data = Path(training_data),\n",
+    "        params_epochs = params.EPOCHS, \n",
+    "        params_batch_size= params.BATCH_SIZE,\n",
+    "        params_is_augmentation= params.AUGMENTATION,\n",
+    "        params_image_size= params.IMAGE_SIZE\n",
+    "        )\n",
+    "        \n",
+    "        return training_config\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Training:\n",
+    "    def __init__(self, confg : TrainingConfig):\n",
+    "        self.config = confg\n",
+    "        \n",
+    "    def get_base_model(self):\n",
+    "        self.model = tf.keras.models.load_model(\n",
+    "            self.config.updata_base_model_path\n",
+    "        )\n",
+    "        \n",
+    "        \n",
+    "    def train_vaid_generator(self):\n",
+    "        datagenerator_kwargs = dict(\n",
+    "            rescale = 1 / 255,\n",
+    "            validation_split = 0.20\n",
+    "        )\n",
+    "        \n",
+    "        dataflow_kwargs = dict(\n",
+    "            target_size = self.config.params_image_size[:-1],\n",
+    "            batch_size = self.config.params_batch_size,\n",
+    "            interpolation = 'bilinear'\n",
+    "        )\n",
+    "        valid_datagernerator = tf.keras.preprocessing.image.ImageDataGenerator(\n",
+    "            **datagenerator_kwargs\n",
+    "        )\n",
+    "        \n",
+    "        self.valid_generator = valid_datagernerator.flow_from_directory(\n",
+    "            directory = self.config.training_data,\n",
+    "            subset = 'validation',\n",
+    "            shuffle = True,\n",
+    "            **dataflow_kwargs\n",
+    "        )\n",
+    "        \n",
+    "        if self.config.params_is_augmentation:\n",
+    "            train_datagenerator = tf.keras.preprocessing.image.ImageDataGenerator(\n",
+    "                \n",
+    "            \n",
+    "            rotation_range = 40,\n",
+    "            horizontal_flip = True,\n",
+    "            width_shift_range = 0.2,\n",
+    "            height_shift_range = 0.2,\n",
+    "            shear_range = 0.2,\n",
+    "            zoom_range = 0.2,\n",
+    "            **datagenerator_kwargs\n",
+    "            )\n",
+    "            \n",
+    "            \n",
+    "        else:\n",
+    "            train_datagenerator = valid_datagernerator\n",
+    "        self.train_generator = train_datagenerator.flow_from_directory(\n",
+    "            directory = self.config.training_data,\n",
+    "            subset = 'training',\n",
+    "            shuffle = True,\n",
+    "            **dataflow_kwargs\n",
+    "        )\n",
+    "    \n",
+    "    @staticmethod\n",
+    "    def save_model(path: Path, model: tf.keras.Model):\n",
+    "        model.save(path)\n",
+    "        \n",
+    "    def train(self):\n",
+    "        self.steps_per_epchs = self.train_generator.samples // self.train_generator.batch_size\n",
+    "        self.validation_steps = self.valid_generator.samples // self.valid_generator.batch_size\n",
+    "        \n",
+    "        self.model.fit(\n",
+    "            self.train_generator,\n",
+    "            epochs = self.config.params_epochs,\n",
+    "            steps_per_epoch = self.steps_per_epchs,\n",
+    "            validation_steps = self.validation_steps,\n",
+    "            validation_data = self.valid_generator\n",
+    "        )\n",
+    "        \n",
+    "        self.save_model(\n",
+    "            path = self.config.training_data,\n",
+    "            model = self.model\n",
+    "        )\n",
+    "\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-07-31 20:16:53,704: INFO: common: yaml file: config\\config.yaml loaded successfully]\n",
+      "[2024-07-31 20:16:53,707: INFO: common: yaml file: params.yaml loaded successfully]\n",
+      "[2024-07-31 20:16:53,709: INFO: common: Created directory  at: artifacts]\n",
+      "[2024-07-31 20:16:53,711: INFO: common: Created directory  at: artifacts\\training]\n",
+      "Found 93 images belonging to 2 classes.\n",
+      "Found 372 images belonging to 2 classes.\n",
+      "Epoch 1/10\n",
+      "[2024-07-31 20:16:55,760: WARNING: module_wrapper: From c:\\Users\\User\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\utils\\tf_utils.py:492: The name tf.ragged.RaggedTensorValue is deprecated. Please use tf.compat.v1.ragged.RaggedTensorValue instead.\n",
+      "]\n",
+      "23/23 [==============================] - 32s 1s/step - loss: 0.6976 - accuracy: 0.5983 - val_loss: 0.5528 - val_accuracy: 0.6750\n",
+      "Epoch 2/10\n",
+      "23/23 [==============================] - 18s 776ms/step - loss: 0.5961 - accuracy: 0.7022 - val_loss: 0.5576 - val_accuracy: 0.8250\n",
+      "Epoch 3/10\n",
+      "23/23 [==============================] - 18s 780ms/step - loss: 0.5489 - accuracy: 0.7612 - val_loss: 0.6042 - val_accuracy: 0.5250\n",
+      "Epoch 4/10\n",
+      "23/23 [==============================] - 18s 779ms/step - loss: 0.5166 - accuracy: 0.8006 - val_loss: 0.5593 - val_accuracy: 0.5750\n",
+      "Epoch 5/10\n",
+      "23/23 [==============================] - 18s 774ms/step - loss: 0.4863 - accuracy: 0.7949 - val_loss: 0.6155 - val_accuracy: 0.5250\n",
+      "Epoch 6/10\n",
+      "23/23 [==============================] - 18s 789ms/step - loss: 0.4486 - accuracy: 0.8062 - val_loss: 0.5774 - val_accuracy: 0.5250\n",
+      "Epoch 7/10\n",
+      "23/23 [==============================] - 18s 772ms/step - loss: 0.4574 - accuracy: 0.8034 - val_loss: 0.5751 - val_accuracy: 0.5125\n",
+      "Epoch 8/10\n",
+      "23/23 [==============================] - 18s 772ms/step - loss: 0.4493 - accuracy: 0.7949 - val_loss: 0.5814 - val_accuracy: 0.5125\n",
+      "Epoch 9/10\n",
+      "23/23 [==============================] - 18s 772ms/step - loss: 0.4414 - accuracy: 0.7921 - val_loss: 0.5636 - val_accuracy: 0.5125\n",
+      "Epoch 10/10\n",
+      "23/23 [==============================] - 18s 794ms/step - loss: 0.4290 - accuracy: 0.8090 - val_loss: 0.5743 - val_accuracy: 0.5000\n",
+      "[2024-07-31 20:20:09,590: INFO: builder_impl: Assets written to: artifacts\\data_ingestion\\unzip\\kidney-ct-scan-image\\assets]\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    config = ConfigurationManager()\n",
+    "    training_config = config.get_training_config()\n",
+    "    training = Training(confg=training_config)\n",
+    "    training.get_base_model()\n",
+    "    training.train_vaid_generator()\n",
+    "    training.train()\n",
+    "    \n",
+    "except Exception as e:\n",
+    "    raise e"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

research/model_evaluation.ipynb

@@ -0,0 +1,339 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.chdir('../')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'d:\\\\MLOps-Project\\\\Kidney-disease-classification-mlops'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = tf.keras.models.load_model('artifacts/training/model.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from pathlib import Path\n",
+    "\n",
+    "@dataclass(frozen=True)\n",
+    "class EvaluationConfig:\n",
+    "    path_of_model: Path\n",
+    "    training_data: Path\n",
+    "    all_params: dict\n",
+    "    mlflow_uri: str\n",
+    "    params_image_size: list\n",
+    "    params_batch_size: int\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cnnClassifier.utils.common import read_yaml, create_directories,save_json\n",
+    "from cnnClassifier.constant import *\n",
+    "\n",
+    "from cnnClassifier.utils.common import read_yaml, create_directories\n",
+    "from cnnClassifier.constant import *\n",
+    "# Configuration\n",
+    "class ConfigurationManager:\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        config_filepath = CONFIG_FILE_PATH,\n",
+    "        params_filepath = PARAMS_FILE_PATH):\n",
+    "\n",
+    "        self.config = read_yaml(config_filepath)\n",
+    "        self.params = read_yaml(params_filepath)\n",
+    "\n",
+    "        create_directories([self.config.atifacts_root])\n",
+    "        \n",
+    "    def get_evaluation_config(self) -> EvaluationConfig:\n",
+    "        eval_config = EvaluationConfig(\n",
+    "            path_of_model='artifacts/training/model.h5',\n",
+    "            training_data='artifacts/data_ingestion/unzip/kidney-ct-scan-image',\n",
+    "            mlflow_uri='https://dagshub.com/azizulhakim8291/Kidney-disease-classification-mlops.mlflow',\n",
+    "            all_params= self.params,\n",
+    "            params_image_size=self.params.IMAGE_SIZE,\n",
+    "            params_batch_size=self.params.BATCH_SIZE\n",
+    "        )\n",
+    "        return eval_config\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "from pathlib import Path\n",
+    "import mlflow\n",
+    "import mlflow.keras\n",
+    "from urllib.parse import urlparse"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Evaluation:\n",
+    "    def __init__(self, config: EvaluationConfig):\n",
+    "        self.config = config\n",
+    "        \n",
+    "    def _valid_generator(self):\n",
+    "\n",
+    "        datagenerator_kwargs = dict(\n",
+    "            rescale = 1./255,\n",
+    "            validation_split=0.30\n",
+    "        )\n",
+    "\n",
+    "        dataflow_kwargs = dict(\n",
+    "            target_size=self.config.params_image_size[:-1],\n",
+    "            batch_size=self.config.params_batch_size,\n",
+    "            interpolation=\"bilinear\"\n",
+    "        )\n",
+    "\n",
+    "        valid_datagenerator = tf.keras.preprocessing.image.ImageDataGenerator(\n",
+    "            **datagenerator_kwargs\n",
+    "        )\n",
+    "\n",
+    "        self.valid_generator = valid_datagenerator.flow_from_directory(\n",
+    "            directory=self.config.training_data,\n",
+    "            subset=\"validation\",\n",
+    "            shuffle=False,\n",
+    "            **dataflow_kwargs\n",
+    "        )\n",
+    "        \n",
+    "    @staticmethod\n",
+    "    def load_model(path: Path) -> tf.keras.Model:\n",
+    "        return tf.keras.models.load_model(path)\n",
+    "    \n",
+    "    \n",
+    "    def evaluation(self):\n",
+    "        self.model = self.load_model(self.config.path_of_model)\n",
+    "        self._valid_generator()\n",
+    "        self.score = model.evaluate(self.valid_generator)\n",
+    "        self.save_score()\n",
+    "        \n",
+    "    def save_score(self):\n",
+    "        scores = {\"loss\": self.score[0], \"accuracy\": self.score[1]}\n",
+    "        save_json(path=Path(\"scores.json\"), data=scores)\n",
+    "        \n",
+    "    def log_into_mlflow(self):\n",
+    "        mlflow.set_registry_uri(self.config.mlflow_uri)\n",
+    "        tracking_url_type_store = urlparse(mlflow.get_tracking_uri()).scheme\n",
+    "        \n",
+    "        with mlflow.start_run():\n",
+    "            mlflow.log_params(self.config.all_params)\n",
+    "            mlflow.log_metrics(\n",
+    "                {\"loss\": self.score[0], \"accuracy\": self.score[1]}\n",
+    "            )\n",
+    "            # Model registry does not work with file store\n",
+    "            if tracking_url_type_store != \"file\":\n",
+    "\n",
+    "                # Register the model\n",
+    "                # There are other ways to use the Model Registry, which depends on the use case,\n",
+    "                # please refer to the doc for more information:\n",
+    "                # https://mlflow.org/docs/latest/model-registry.html#api-workflow\n",
+    "                mlflow.keras.log_model(self.model, \"model\", registered_model_name=\"VGG16Model\")\n",
+    "            else:\n",
+    "                mlflow.keras.log_model(self.model, \"model\")\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-08-01 23:40:02,445: INFO: _client: HTTP Request: GET https://dagshub.com/api/v1/repos/azizulhakim8291/Kidney-disease-classification-mlops \"HTTP/1.1 200 OK\"]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">Initialized MLflow to track repo <span style=\"color: #008000; text-decoration-color: #008000\">\"azizulhakim8291/Kidney-disease-classification-mlops\"</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "Initialized MLflow to track repo \u001b[32m\"azizulhakim8291/Kidney-disease-classification-mlops\"\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-08-01 23:40:02,453: INFO: helpers: Initialized MLflow to track repo \"azizulhakim8291/Kidney-disease-classification-mlops\"]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">Repository azizulhakim8291/Kidney-disease-classification-mlops initialized!\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "Repository azizulhakim8291/Kidney-disease-classification-mlops initialized!\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-08-01 23:40:02,458: INFO: helpers: Repository azizulhakim8291/Kidney-disease-classification-mlops initialized!]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import dagshub\n",
+    "dagshub.init(repo_owner='azizulhakim8291', repo_name='Kidney-disease-classification-mlops', mlflow=True)\n",
+    "\n",
+    "import mlflow\n",
+    "with mlflow.start_run():\n",
+    "  mlflow.log_param('parameter name', 'value')\n",
+    "  mlflow.log_metric('metric name', 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-08-01 23:44:03,754: INFO: common: yaml file: config\\config.yaml loaded successfully]\n",
+      "[2024-08-01 23:44:03,764: INFO: common: yaml file: params.yaml loaded successfully]\n",
+      "[2024-08-01 23:44:03,770: INFO: common: Created directory  at: artifacts]\n",
+      "Found 139 images belonging to 2 classes.\n",
+      "9/9 [==============================] - 13s 1s/step - loss: 0.5003 - accuracy: 0.9568\n",
+      "[2024-08-01 23:44:17,498: INFO: common: Json file saved at: scores.json]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024/08/01 23:44:20 WARNING mlflow.tensorflow: You are saving a TensorFlow Core model or Keras model without a signature. Inference with mlflow.pyfunc.spark_udf() will not work unless the model's pyfunc representation accepts pandas DataFrames as inference inputs.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-08-01 23:44:22,432: WARNING: save: Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 14). These functions will not be directly callable after loading.]\n",
+      "INFO:tensorflow:Assets written to: C:\\Users\\User\\AppData\\Local\\Temp\\tmp8n0wc3k0\\model\\data\\model\\assets\n",
+      "[2024-08-01 23:44:24,256: INFO: builder_impl: Assets written to: C:\\Users\\User\\AppData\\Local\\Temp\\tmp8n0wc3k0\\model\\data\\model\\assets]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Registered model 'VGG16Model' already exists. Creating a new version of this model...\n",
+      "2024/08/01 23:47:06 INFO mlflow.tracking._model_registry.client: Waiting up to 300 seconds for model version to finish creation.                     Model name: VGG16Model, version 2\n",
+      "Created version '2' of model 'VGG16Model'.\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    config = ConfigurationManager()\n",
+    "    eval_config = config.get_evaluation_config()\n",
+    "    evaluation = Evaluation(eval_config)\n",
+    "    evaluation.evaluation()\n",
+    "    evaluation.log_into_mlflow()\n",
+    "\n",
+    "except Exception as e:\n",
+    "   raise e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

scores.json

@@ -0,0 +1,4 @@
+{
+    "loss": 14.36583423614502,
+    "accuracy": 0.5179855823516846
+}

setup.py

@@ -0,0 +1,27 @@
+import setuptools
+with open('README.md', 'r') as f:
+    long_description = f.read()
+    
+__version__ = '0.0.0'
+
+REPO_NAME = "Kidney-disease-classification-mlops"
+AUTHOR_USER_NAME = "HAKIM-ML"
+SRC_REPO = "cnnClassifier"
+AUTHOR_EMAIL = "[email protected]"
+
+
+setuptools.setup(
+    name=SRC_REPO,
+    version=__version__,
+    author=AUTHOR_USER_NAME,
+    author_email=AUTHOR_EMAIL,
+    description="A small python package for CNN app",
+    long_description=long_description,
+    long_description_content="text/markdown",
+    url=f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}",
+    project_urls={
+        "Bug Tracker": f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}/issues",
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src")
+)

src/cnnClassifier/__init__.py

@@ -0,0 +1,22 @@
+import os
+import sys
+import logging
+
+logging_str = "[%(asctime)s: %(levelname)s: %(module)s: %(message)s]"
+
+log_dir = "logs"
+log_filepath = os.path.join(log_dir,"running_logs.log")
+os.makedirs(log_dir, exist_ok=True)
+
+
+logging.basicConfig(
+    level= logging.INFO,
+    format= logging_str,
+
+    handlers=[
+        logging.FileHandler(log_filepath),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger("cnnClassifierLogger")

src/cnnClassifier/components/data_ingestion.py

@@ -0,0 +1,40 @@
+# components
+
+import os
+import zipfile
+import gdown
+from cnnClassifier import logger
+from cnnClassifier.utils.common import get_size
+from cnnClassifier.entity.config_entity import DataIngestionConfig
+
+class DataIngestion:
+    def __init__(self, config: DataIngestionConfig):
+        self.config = config
+        
+    def download_file(self) -> str:
+        try:
+            dataset_url = self.config.source_URL
+            zip_download_dir = self.config.local_data_file
+            os.makedirs('artifacts/datasets', exist_ok=True)
+            logger.info(f'Downloading data from {dataset_url} into {zip_download_dir}')
+            
+            file_id = dataset_url.split('/')[-2]
+            prefix = 'https://drive.google.com/uc?/export=download&id='
+            gdown.download(prefix + file_id, zip_download_dir)
+            logger.info(f'Downloaded data from {dataset_url} into {zip_download_dir}')
+            
+        except Exception as e:
+            raise e
+        
+        
+        
+    def extract_zip_file(self):
+        """
+        zip_file_path: str
+        Extracts the zip file into the data directory
+        Function returns None
+        """
+        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)

src/cnnClassifier/components/evaluation.py

@@ -0,0 +1,83 @@
+import tensorflow as tf
+from pathlib import Path
+import mlflow
+import mlflow.keras
+from urllib.parse import urlparse
+from cnnClassifier.utils.common import save_json
+from cnnClassifier.entity.config_entity import EvaluationConfig
+
+
+model = tf.keras.models.load_model('artifacts/training/model.h5')
+
+import dagshub
+dagshub.init(repo_owner='azizulhakim8291', repo_name='Kidney-disease-classification-mlops', mlflow=True)
+
+import mlflow
+with mlflow.start_run():
+  mlflow.log_param('parameter name', 'value')
+  mlflow.log_metric('metric name', 1)
+
+
+class Evaluation:
+    def __init__(self, config: EvaluationConfig):
+        self.config = config
+        
+    def _valid_generator(self):
+
+        datagenerator_kwargs = dict(
+            rescale = 1./255,
+            validation_split=0.30
+        )
+
+        dataflow_kwargs = dict(
+            target_size=self.config.params_image_size[:-1],
+            batch_size=self.config.params_batch_size,
+            interpolation="bilinear"
+        )
+
+        valid_datagenerator = tf.keras.preprocessing.image.ImageDataGenerator(
+            **datagenerator_kwargs
+        )
+
+        self.valid_generator = valid_datagenerator.flow_from_directory(
+            directory=self.config.training_data,
+            subset="validation",
+            shuffle=False,
+            **dataflow_kwargs
+        )
+        
+    @staticmethod
+    def load_model(path: Path) -> tf.keras.Model:
+        return tf.keras.models.load_model(path)
+    
+    
+    def evaluation(self):
+        self.model = self.load_model(self.config.path_of_model)
+        self._valid_generator()
+        self.score = model.evaluate(self.valid_generator)
+        self.save_score()
+        
+    def save_score(self):
+        scores = {"loss": self.score[0], "accuracy": self.score[1]}
+        save_json(path=Path("scores.json"), data=scores)
+        
+    def log_into_mlflow(self):
+        mlflow.set_registry_uri(self.config.mlflow_uri)
+        tracking_url_type_store = urlparse(mlflow.get_tracking_uri()).scheme
+        
+        with mlflow.start_run():
+            mlflow.log_params(self.config.all_params)
+            mlflow.log_metrics(
+                {"loss": self.score[0], "accuracy": self.score[1]}
+            )
+            # Model registry does not work with file store
+            if tracking_url_type_store != "file":
+
+                # Register the model
+                # There are other ways to use the Model Registry, which depends on the use case,
+                # please refer to the doc for more information:
+                # https://mlflow.org/docs/latest/model-registry.html#api-workflow
+                mlflow.keras.log_model(self.model, "model", registered_model_name="VGG16Model")
+            else:
+                mlflow.keras.log_model(self.model, "model")
+        

src/cnnClassifier/components/prepare_base_model.py

@@ -0,0 +1,67 @@
+import os
+from pathlib import Path
+import tensorflow as tf
+from cnnClassifier.config.configuration import PrepareBaseModelConfig
+
+class PrepareBaseModel:
+    def __init__(self, config: PrepareBaseModelConfig):
+        self.config = config
+
+    
+    def get_base_model(self):
+        self.model = tf.keras.applications.vgg16.VGG16(
+            input_shape=self.config.params_image_size,
+            weights=self.config.params_weights,
+            include_top=self.config.params_include_top
+        )
+
+        self.save_model(path=self.config.base_model_path, model=self.model)
+
+    
+
+    @staticmethod
+    def _prepare_full_model(model, classes, freeze_all, freeze_till, learning_rate):
+        if freeze_all:
+            for layer in model.layers:
+                model.trainable = False
+        elif (freeze_till is not None) and (freeze_till > 0):
+            for layer in model.layers[:-freeze_till]:
+                model.trainable = False
+
+        flatten_in = tf.keras.layers.Flatten()(model.output)
+        prediction = tf.keras.layers.Dense(
+            units=classes,
+            activation="softmax"
+        )(flatten_in)
+
+        full_model = tf.keras.models.Model(
+            inputs=model.input,
+            outputs=prediction
+        )
+
+        full_model.compile(
+            optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate),
+            loss=tf.keras.losses.CategoricalCrossentropy(),
+            metrics=["accuracy"]
+        )
+
+        full_model.summary()
+        return full_model
+    
+    
+    def update_base_model(self):
+        self.full_model = self._prepare_full_model(
+            model=self.model,
+            classes=self.config.params_classes,
+            freeze_all=True,
+            freeze_till=None,
+            learning_rate=self.config.params_learning_rate
+        )
+
+        self.save_model(path=self.config.updated_base_model_path, model=self.full_model)
+
+    
+        
+    @staticmethod
+    def save_model(path: Path, model: tf.keras.Model):
+        model.save(path)

src/cnnClassifier/components/training.py

@@ -0,0 +1,86 @@
+from cnnClassifier.entity.config_entity import TrainingConfig
+import tensorflow as tf
+from pathlib import Path
+
+class Training:
+    def __init__(self, config: TrainingConfig):
+        self.config = config
+
+    
+    def get_base_model(self):
+        self.model = tf.keras.models.load_model(
+            self.config.updated_base_model_path
+        )
+
+    def train_valid_generator(self):
+
+        datagenerator_kwargs = dict(
+            rescale = 1./255,
+            validation_split=0.20
+        )
+
+        dataflow_kwargs = dict(
+            target_size=self.config.params_image_size[:-1],
+            batch_size=self.config.params_batch_size,
+            interpolation="bilinear"
+        )
+
+        valid_datagenerator = tf.keras.preprocessing.image.ImageDataGenerator(
+            **datagenerator_kwargs
+        )
+
+        self.valid_generator = valid_datagenerator.flow_from_directory(
+            directory=self.config.training_data,
+            subset="validation",
+            shuffle=False,
+            **dataflow_kwargs
+        )
+
+        if self.config.params_is_augmentation:
+            train_datagenerator = tf.keras.preprocessing.image.ImageDataGenerator(
+                rotation_range=40,
+                horizontal_flip=True,
+                width_shift_range=0.2,
+                height_shift_range=0.2,
+                shear_range=0.2,
+                zoom_range=0.2,
+                **datagenerator_kwargs
+            )
+        else:
+            train_datagenerator = valid_datagenerator
+
+        self.train_generator = train_datagenerator.flow_from_directory(
+            directory=self.config.training_data,
+            subset="training",
+            shuffle=True,
+            **dataflow_kwargs
+        )
+
+    
+    @staticmethod
+    def save_model(path: Path, model: tf.keras.Model):
+        model.save(path)
+
+
+
+    
+    def train(self):
+        self.steps_per_epoch = self.train_generator.samples // self.train_generator.batch_size
+        self.validation_steps = self.valid_generator.samples // self.valid_generator.batch_size
+
+        self.model.fit(
+            self.train_generator,
+            epochs=self.config.params_epochs,
+            steps_per_epoch=self.steps_per_epoch,
+            validation_steps=self.validation_steps,
+            validation_data=self.valid_generator
+        )
+
+        self.save_model(
+            path=self.config.trained_model_path,
+            model=self.model
+        )
+
+
+
+        

src/cnnClassifier/config/configuration.py

@@ -0,0 +1,88 @@
+from cnnClassifier.utils.common import read_yaml, create_directories
+from cnnClassifier.constant import *
+from cnnClassifier.entity.config_entity import (DataIngestionConfig,
+                                                PrepareBaseModelConfig,
+                                                TrainingConfig,EvaluationConfig)
+import os
+
+
+
+class ConfigurationManager:
+    def __init__(
+        self,
+        config_filepath = CONFIG_FILE_PATH,
+        params_filepath = PARAMS_FILE_PATH
+    ):
+        self.config = read_yaml(config_filepath)
+        self.params = read_yaml(params_filepath)
+        
+        create_directories([self.config.atifacts_root])
+        
+        
+        
+    def get_data_ingestion_config(self) -> DataIngestionConfig:
+        config = self.config.data_ingestion
+        create_directories([config.root_dir])
+        
+        data_ingestion_config = DataIngestionConfig(
+            root_dir=config.root_dir,
+            source_URL=config.source_URL,
+            local_data_file=config.local_data_file,
+            unzip_dir=config.unzip_dir
+        )
+        
+        return data_ingestion_config
+    
+    
+    def get_prepare_base_model_config(self) -> PrepareBaseModelConfig:
+        config = self.config.prepare_base_model
+        
+        create_directories([config.root_dir])
+
+        prepare_base_model_config = PrepareBaseModelConfig(
+            root_dir=Path(config.root_dir),
+            base_model_path=Path(config.base_model_path),
+            updated_base_model_path=Path(config.updated_base_model_path),
+            params_image_size=self.params.IMAGE_SIZE,
+            params_learning_rate=self.params.LEARNING_RATE,
+            params_include_top=self.params.INCLUDE_TOP,
+            params_weights=self.params.WEIGHTS,
+            params_classes=self.params.CLASSES
+        )
+
+        return prepare_base_model_config
+    
+    
+    def get_training_config(self) -> TrainingConfig:
+        training = self.config.training
+        prepare_base_model = self.config.prepare_base_model
+        params = self.params
+        training_data = os.path.join(self.config.data_ingestion.unzip_dir, "kidney-ct-scan-image")
+        create_directories([
+            Path(training.root_dir)
+        ])
+
+        training_config = TrainingConfig(
+            root_dir=Path(training.root_dir),
+            trained_model_path=Path(training.trained_model_path),
+            updated_base_model_path=Path(prepare_base_model.updated_base_model_path),
+            training_data=Path(training_data),
+            params_epochs=params.EPOCHS,
+            params_batch_size=params.BATCH_SIZE,
+            params_is_augmentation=params.AUGMENTATION,
+            params_image_size=params.IMAGE_SIZE
+        )
+
+        return training_config
+    
+    def get_evaluation_config(self) -> EvaluationConfig:
+        eval_config = EvaluationConfig(
+            path_of_model='artifacts/training/model.h5',
+            training_data='artifacts/data_ingestion/unzip/kidney-ct-scan-image',
+            mlflow_uri='https://dagshub.com/azizulhakim8291/Kidney-disease-classification-mlops.mlflow',
+            all_params= self.params,
+            params_image_size=self.params.IMAGE_SIZE,
+            params_batch_size=self.params.BATCH_SIZE
+        )
+        return eval_config
+    

src/cnnClassifier/constant/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+CONFIG_FILE_PATH = Path("config/config.yaml")
+PARAMS_FILE_PATH = Path("params.yaml")

src/cnnClassifier/entity/config_entity.py

@@ -0,0 +1,46 @@
+# entity
+from dataclasses import dataclass
+from pathlib import Path
+
+@dataclass(frozen=True)
+class DataIngestionConfig:
+    root_dir: Path
+    source_URL: str
+    local_data_file: Path
+    unzip_dir: Path
+    
+@dataclass(frozen=True)    
+class PrepareBaseModelConfig:
+    root_dir: Path
+    base_model_path: Path
+    updated_base_model_path: Path
+    params_image_size: list
+    params_learning_rate: float
+    params_include_top: bool
+    params_weights: str
+    params_classes: int
+    
+    
+    
+@dataclass(frozen=True)
+class TrainingConfig:
+    root_dir: Path
+    trained_model_path: Path
+    updated_base_model_path: Path
+    training_data: Path
+    params_epochs: int
+    params_batch_size: int
+    params_is_augmentation: bool
+    params_image_size: list
+    
+    
+
+
+@dataclass(frozen=True)
+class EvaluationConfig:
+    path_of_model: Path
+    training_data: Path
+    all_params: dict
+    mlflow_uri: str
+    params_image_size: list
+    params_batch_size: int

src/cnnClassifier/pipeline/predict.py

@@ -0,0 +1,30 @@
+import numpy as np
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+import os
+
+
+
+class Prediction:
+    def __init__(self,filename):
+        self.filename =filename
+
+
+    
+    def predict(self):
+        # load model
+        model = load_model("model.h5")
+
+        imagename = self.filename
+        test_image = image.load_img(imagename, target_size = (224,224))
+        test_image = image.img_to_array(test_image)
+        test_image = np.expand_dims(test_image, axis = 0)
+        result = np.argmax(model.predict(test_image), axis=1)
+        print(result)
+
+        if result[0] == 1:
+            prediction = 'Normal'
+        else:
+            prediction = 'Tumor'
+        
+        return prediction

src/cnnClassifier/pipeline/stage_01_data_ingestion.py

@@ -0,0 +1,28 @@
+from cnnClassifier.config.configuration import ConfigurationManager
+from cnnClassifier.components.data_ingestion import DataIngestion
+from cnnClassifier import logger
+STAGE_NAME = "Data Ingestion stage"
+
+
+class DataIngestionTrainingPipeline:
+    def __init__(self):
+        pass
+
+    def main(self):
+        config = ConfigurationManager()
+        data_ingestion_config = config.get_data_ingestion_config()
+        data_ingestion = DataIngestion(config=data_ingestion_config)
+        data_ingestion.download_file()
+        data_ingestion.extract_zip_file()
+
+
+
+if __name__ == '__main__':
+    try:
+        logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<")
+        obj = DataIngestionTrainingPipeline()
+        obj.main()
+        logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+    except Exception as e:
+        logger.exception(e)
+        raise e

src/cnnClassifier/pipeline/stage_02_prepare_base_model.py

@@ -0,0 +1,31 @@
+from cnnClassifier.config.configuration import ConfigurationManager
+from cnnClassifier.components.prepare_base_model import PrepareBaseModel
+from cnnClassifier import logger
+
+
+STAGE_NAME = "Prepare base model"
+
+
+class PrepareBaseModelTrainingPipeline:
+    def __init__(self):
+        pass
+
+    def main(self):
+        config = ConfigurationManager()
+        prepare_base_model_config = config.get_prepare_base_model_config()
+        prepare_base_model = PrepareBaseModel(config=prepare_base_model_config)
+        prepare_base_model.get_base_model()
+        prepare_base_model.update_base_model()
+
+
+    
+if __name__ == '__main__':
+    try:
+        logger.info(f"*******************")
+        logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<")
+        obj = PrepareBaseModelTrainingPipeline()
+        obj.main()
+        logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+    except Exception as e:
+        logger.exception(e)
+        raise e

src/cnnClassifier/pipeline/stage_03_train_model.py

@@ -0,0 +1,33 @@
+from cnnClassifier.config.configuration import ConfigurationManager
+from cnnClassifier.components.training import Training
+
+from cnnClassifier import logger
+
+
+STAGE_NAME = "Model Training"
+
+
+class ModelTrainingPipeline:
+    def __init__(self):
+        pass
+
+    def main(self):
+        config = ConfigurationManager()
+        training_config = config.get_training_config()
+        training = Training(config=training_config)
+        training.get_base_model()
+        training.train_valid_generator()
+        training.train()
+
+
+    
+if __name__ == '__main__':
+    try:
+        logger.info(f"*******************")
+        logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<")
+        obj = ModelTrainingPipeline()
+        obj.main()
+        logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+    except Exception as e:
+        logger.exception(e)
+        raise e

src/cnnClassifier/pipeline/stage_04_evaluation.py

@@ -0,0 +1,32 @@
+from cnnClassifier.config.configuration import ConfigurationManager
+from cnnClassifier.components.evaluation import Evaluation
+
+from cnnClassifier import logger
+
+
+STAGE_NAME = "Evaluation"
+
+
+class EvaluationTrainingPipeline:
+    def __init__(self):
+        pass
+
+    def main(self):
+        config = ConfigurationManager()
+        eval_config = config.get_evaluation_config()
+        evaluation = Evaluation(eval_config)
+        evaluation.evaluation()
+        evaluation.log_into_mlflow()
+
+
+    
+if __name__ == '__main__':
+    try:
+        logger.info(f"*******************")
+        logger.info(f">>>>>> stage {STAGE_NAME} started <<<<<<")
+        obj = EvaluationTrainingPipeline()
+        obj.main()
+        logger.info(f">>>>>> stage {STAGE_NAME} completed <<<<<<\n\nx==========x")
+    except Exception as e:
+        logger.exception(e)
+        raise e

src/cnnClassifier/utils/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+CONFIG_FILE_PATH = Path("config/config.yaml")
+PARAMS_FILE_PATH = Path("params.yaml")

src/cnnClassifier/utils/common.py

@@ -0,0 +1,145 @@
+import os
+from box.exceptions import BoxValueError
+import yaml
+from cnnClassifier import logger
+import json
+import joblib
+from ensure import ensure_annotations
+from box import ConfigBox
+from pathlib import Path
+from typing import Any
+import base64
+
+
+
+@ensure_annotations
+def read_yaml(path_to_yaml: Path) -> ConfigBox:
+    """reads yaml file and returns
+
+    Args:
+        path_to_yaml (str): path like input
+
+    Raises:
+        ValueError: if yaml file is empty
+        e: empty file
+
+    Returns:
+        ConfigBox: ConfigBox type
+    """
+    try:
+        with open(path_to_yaml) as yaml_file:
+            content = yaml.safe_load(yaml_file)
+            logger.info(f"yaml file: {path_to_yaml} loaded successfully")
+            return ConfigBox(content)
+    except BoxValueError:
+        raise ValueError("yaml file is empty")
+    except Exception as e:
+        raise e
+    
+    
+    
+@ensure_annotations
+def create_directories(path_to_directories: list, verbose = True):
+    """create list of directories
+
+    Args:
+        path_to_directories (list): list of path of directories
+        ignore_log (bool, optional): ignore if multiple dirs is to be created. Defaults to False.
+    """
+    
+    for path in path_to_directories:
+        os.makedirs(path, exist_ok=True)
+        if verbose:
+            logger.info(f'Created directory  at: {path}')
+            
+@ensure_annotations
+def save_json(path: Path, data: dict):
+    """save json data
+
+    Args:
+        path (Path): path to json file
+        data (dict): data to be saved in json file
+    """
+    
+    
+    with open(path, 'w') as f:
+        json.dump(data, f, indent=4)
+        
+    logger.info(f'Json file saved at: {path}')
+    
+    
+    
+    
+@ensure_annotations
+def load_json(path: Path) -> ConfigBox:
+    """load json files data
+
+    Args:
+        path (Path): path to json file
+
+    Returns:
+        ConfigBox: data as class attributes instead of dict
+    """
+    
+    with open(path, 'r') as f:
+        content = json.load(f)
+
+    logger.info(f"Json file loaded successfully from: {path}")
+    return ConfigBox
+
+
+@ensure_annotations
+def save_bin(data: Any, path: Path):
+    """save binary file
+
+    Args:
+        data (Any): data to be saved as binary
+        path (Path): path to binary file
+    """
+    joblib.dump(value=data, filename=path)
+    logger.info(f'binary file saved at: {path}')
+    
+    
+    
+@ensure_annotations
+def load_bin(path: Path) -> ConfigBox:
+    """load binary data
+
+    Args:
+        path (Path): path to binary file
+
+    Returns:
+        Any: object stored in the file
+    """
+    
+    data = joblib.load(path)
+    logger.info(f'binary file has been loaded successfully from : {path}')
+    return data
+
+
+@ensure_annotations
+def get_size(path: Path) -> str:
+    '''
+    get size in KB
+    
+    Args:
+        Path (Path): path of the file
+        
+    Returns:
+        str: size in KB'''
+        
+    size_in_kb = round(os.path.getsize(path)/1024)
+    return f"~ {size_in_kb} KB"
+
+
+def decodeImage(imgstring, fileName):
+    imgdata = base64.b64decode(imgstring)
+    with open(fileName, 'wb') as f:
+        f.write(imgdata)
+        f.close()
+        
+        
+        
+def encodeImageIntoBase64(croppedImagePath):
+    with open(croppedImagePath, 'rb') as f:
+        return base64.b64decode(f.read())

template.py

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+import logging
+
+logging.basicConfig(level=logging.INFO, format='[%(asctime)s]: %(message)s:')
+
+project_name = 'cnnClassifier'
+
+list_of_files = [
+    '.github/workflows/.gitkeep',
+    f"src/{project_name}/__init__.py",
+    f"src/{project_name}/components/__init__.py",
+    f"src/{project_name}/utils/__init__.py",
+    f"src/{project_name}/config/__init__.py",
+    f"src/{project_name}/config/configuration.py",
+    f"src/{project_name}/pipeline/__init__.py",
+    f"src/{project_name}/entity/__init__.py",
+    f"src/{project_name}/constant/__init__.py",
+    'config/config.yaml',
+    'dvc.yaml',
+    'params.yaml',
+    'requirements.txt',
+    'setup.py',
+    'research/trials.ipynb',
+
+]
+
+for filepath in list_of_files:
+    filepath = Path(filepath)
+    filedir, filename = os.path.split(filepath)
+    
+    
+    if filedir != "":
+        os.makedirs(filedir, exist_ok=True)
+        logging.info(f'Creating directory; {filedir} for the file: {filename}')
+        
+    if (not os.path.exists(filepath)) or (os.path.getsize(filepath) == 0):
+        with open(filepath, 'w') as f:
+            pass
+        logging.info(f'Creating an empty file: {filename}')
+    else:
+        logging.info(f'File: {filename} already exists')