all files added

Kidney-Disease-Classifcation/.dvc/.gitignore

@@ -0,0 +1,3 @@
+/config.local
+/tmp
+/cache

Kidney-Disease-Classifcation/.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

Kidney-Disease-Classifcation/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

Kidney-Disease-Classifcation/.gitignore

@@ -0,0 +1,161 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Data Artifacts
+artifacts/*
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  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/
+
+#mlflow runs
+mlruns/
+
+#input images
+inputImage.jpg

Kidney-Disease-Classifcation/.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+-   repo: https://github.com/psf/black
+    rev: 23.3.0
+    hooks:
+    -   id: black

Kidney-Disease-Classifcation/README.md

@@ -0,0 +1,70 @@
+# Kidney Tumor, Cyst, or Stone Classification
+![alt text](https://github.com/Shrey-patel-07/Kidney-Disease-Classifcation/blob/b19262be45c45d9e375e2119d89462ccfc7475c1/templates/kidney_ctscan.png)
+
+## Project Overview
+The main goal of this project is to develop a reliable and efficient deep-learning model that can accurately classify kidney tumors and Stone from medical images.
+
+## Introduction
+Kidney Disease Classification is a project utilizing deep learning techniques to classify Kidney Tumor and Stone diseases from [medical images dataset](https://www.kaggle.com/datasets/nazmul0087/ct-kidney-dataset-normal-cyst-tumor-and-stone/). This project leverages the power of Deep Learning, Machine Learning Operations (MLOps) practices, Data Version Control (DVC). It integrates with DagsHub for collaboration and versioning.
+
+## Dagshub Project Pipeline
+![alt text](https://github.com/Shrey-patel-07/Kidney-Disease-Classifcation/blob/2ad0c02af659c2c1e82798524897d831349b1071/templates/dagshub-kidney_disease_classification.png)
+
+## Mlflow Stats
+![alt text](https://github.com/Shrey-patel-07/Kidney-Disease-Classifcation/blob/2ad0c02af659c2c1e82798524897d831349b1071/templates/mlflow-kidney_disease_classification.png)
+
+## Importance of the Project
+- **Enhancing Healthcare**: By providing accurate and quick disease classification, this project aims to improve patient care and diagnostic accuracy significantly.
+- **Research and Development**: It serves as a tool for researchers to analyze medical images more effectively, paving the way for discoveries in the medical field.
+- **Educational Value**: This project can be a learning platform for students and professionals interested in deep learning and medical image analysis.
+
+## Technical Overview
+- **Deep Learning Frameworks**: Utilizes popular frameworks like TensorFlow or PyTorch for building and training the classification models.
+- **Data Version Control (DVC)**: Manages and versions large datasets and machine learning models, ensuring reproducibility and streamlined data pipelines.
+- **Git Integration**: For source code management and version control, making the project easily maintainable and scalable.
+- **MLOps Practices**: Incorporates best practices in machine learning operations to automate workflows, from data preparation to model deployment.
+- **DagsHub Integration**: Facilitates collaboration, data and model versioning, experiment tracking, and more in a user-friendly platform.
+
+## How to run?
+### STEPS:
+
+Clone the repository
+
+```bash
+https://github.com/krishnaik06/Kidney-Disease-Classification-Deep-Learning-Project
+```
+### STEP 01- Create a conda environment after opening the repository
+
+```bash
+conda create -n venv python=3.11 -y
+```
+
+```bash
+conda activate venv
+```
+
+
+### STEP 02- install the requirements
+```bash
+pip install -r requirements.txt
+```
+
+```bash
+# Finally run the following command
+python app.py
+```
+
+Now,
+```bash
+open up your local host and port
+```
+
+## To Run the Pipeline
+```bash
+dvc repro
+```
+---
+
+This project is still in development, and we welcome contributions of all kinds: from model development and data processing to documentation and bug fixes.
+
+**Join me in this exciting journey to revolutionize the field of medical image classification with AI!**

Kidney-Disease-Classifcation/app.py

@@ -0,0 +1,50 @@
+import sys
+
+sys.path.append("./src")
+
+from kidney_classification.pipeline.prediction import PredictionPipeline
+from kidney_classification.utils.common import decodeImage
+from flask_cors import CORS, cross_origin
+import os
+from flask import Flask, request, jsonify, render_template
+
+
+os.putenv("LANG", "en_US.UTF-8")
+os.putenv("LC_ALL", "en_US.UTF-8")
+
+app = Flask(__name__)
+CORS(app)
+
+
+class ClientApp:
+    def __init__(self):
+        self.filename = "inputImage.jpg"
+        self.classifier = PredictionPipeline(self.filename)
+
+
+@app.route("/", methods=["GET"])
+@cross_origin()
+def home():
+    return render_template("index.html")
+
+
+@app.route("/train", methods=["GET", "POST"])
+@cross_origin()
+def trainRoute():
+    os.system("dvc repro")
+    return "Training done successfully!"
+
+
+@app.route("/predict", methods=["POST"])
+@cross_origin()
+def predictRoute():
+    image = request.json["image"]
+    decodeImage(image, clApp.filename)
+    result = clApp.classifier.predict()
+    return jsonify(result)
+
+
+if __name__ == "__main__":
+    clApp = ClientApp()
+
+    app.run(host="0.0.0.0", port=8080)  # for AWS

Kidney-Disease-Classifcation/config/config.yaml

@@ -0,0 +1,19 @@
+artifacts_root: artifacts
+
+
+data_ingestion:
+  root_dir: artifacts/data_ingestion
+  source_URL: https://drive.google.com/file/d/1BBxDX8JqV-WvNyOzYbqfrk3THFLBpEWF/view?usp=sharing
+  local_data_file: artifacts/data_ingestion/data.zip
+  unzip_dir: artifacts/data_ingestion
+
+
+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.keras
+
+
+training:
+  root_dir: artifacts/training
+  trained_model_path: artifacts/training/model.h5

Kidney-Disease-Classifcation/dvc.lock

@@ -0,0 +1,112 @@
+schema: '2.0'
+stages:
+  data_ingestion:
+    cmd: python src/kidney_classification/pipeline/stage_01_data_ingestion.py
+    deps:
+    - path: config/config.yaml
+      hash: md5
+      md5: 23d61aa500e4da63569da56d61ddb49e
+      size: 568
+    - path: src/kidney_classification/pipeline/stage_01_data_ingestion.py
+      hash: md5
+      md5: 0496157b33ff2c7182935a33c605f461
+      size: 955
+    outs:
+    - path: artifacts/data_ingestion/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone
+      hash: md5
+      md5: 47292b3e13804acbce0f2b4ce55edc57.dir
+      size: 887719156
+      nfiles: 5511
+  prepare_base_model:
+    cmd: python src/kidney_classification/pipeline/stage_02_prepare_base_model.py
+    deps:
+    - path: config/config.yaml
+      hash: md5
+      md5: 23d61aa500e4da63569da56d61ddb49e
+      size: 568
+    - path: src/kidney_classification/pipeline/stage_02_prepare_base_model.py
+      hash: md5
+      md5: 27f16408dee8b42a215b576052e54bb2
+      size: 950
+    params:
+      params.yaml:
+        CLASSES: 4
+        IMAGE_SIZE:
+        - 150
+        - 150
+        - 3
+        INCLUDE_TOP: false
+        WEIGHTS: imagenet
+    outs:
+    - path: artifacts/prepare_base_model
+      hash: md5
+      md5: 2721c46e50849883acd55e5d4e3dcefb.dir
+      size: 60010269
+      nfiles: 1
+  training:
+    cmd: python src/kidney_classification/pipeline/stage_03_model_training.py
+    deps:
+    - path: artifacts/data_ingestion/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone
+      hash: md5
+      md5: ec42dfce2ae993cf49f6d499a389c93e.dir
+      size: 1661580918
+      nfiles: 12446
+    - path: artifacts/prepare_base_model
+      hash: md5
+      md5: a4f718a24c253b4e539f7ba2dc9d3442.dir
+      size: 59997688
+      nfiles: 1
+    - path: config/config.yaml
+      hash: md5
+      md5: bc47b5f88a0220822ff7921144b69204
+      size: 565
+    - path: src/kidney_classification/pipeline/stage_03_model_training.py
+      hash: md5
+      md5: cb8342c5c2f23c4d395f299924161231
+      size: 941
+    params:
+      params.yaml:
+        BATCH_SIZE: 32
+        EPOCHS: 15
+        IMAGE_SIZE:
+        - 150
+        - 150
+        - 3
+    outs:
+    - path: artifacts/training/model.h5
+      hash: md5
+      md5: 17969099556c165c584938f53a3fc085
+      size: 62136448
+  evaluation:
+    cmd: python src/kidney_classification/pipeline/stage_04_model_evaluation_with_mlflow.py
+    deps:
+    - path: artifacts/data_ingestion/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone
+      hash: md5
+      md5: ec42dfce2ae993cf49f6d499a389c93e.dir
+      size: 1661580918
+      nfiles: 12446
+    - path: artifacts/training/model.h5
+      hash: md5
+      md5: 17969099556c165c584938f53a3fc085
+      size: 62136448
+    - path: config/config.yaml
+      hash: md5
+      md5: bc47b5f88a0220822ff7921144b69204
+      size: 565
+    - path: src/kidney_classification/pipeline/stage_04_model_evaluation_with_mlflow.py
+      hash: md5
+      md5: 7c91c2fdf529e4dcf7dec2684eb3d212
+      size: 892
+    params:
+      params.yaml:
+        BATCH_SIZE: 32
+        EPOCHS: 15
+        IMAGE_SIZE:
+        - 150
+        - 150
+        - 3
+    outs:
+    - path: scores.json
+      hash: md5
+      md5: e80b69c44a4cf771b208a549d9e5ae30
+      size: 58

Kidney-Disease-Classifcation/dvc.yaml

@@ -0,0 +1,50 @@
+stages:
+  data_ingestion:
+    cmd: python src/kidney_classification/pipeline/stage_01_data_ingestion.py
+    deps:
+      - src/kidney_classification/pipeline/stage_01_data_ingestion.py
+      - config/config.yaml
+    outs:
+      - artifacts/data_ingestion/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone
+
+  prepare_base_model:
+    cmd: python src/kidney_classification/pipeline/stage_02_prepare_base_model.py
+    deps:
+      - src/kidney_classification/pipeline/stage_02_prepare_base_model.py
+      - config/config.yaml
+    params:
+      - IMAGE_SIZE
+      - INCLUDE_TOP
+      - CLASSES
+      - WEIGHTS
+    outs:
+      - artifacts/prepare_base_model
+
+  training:
+    cmd: python src/kidney_classification/pipeline/stage_03_model_training.py
+    deps:
+      - src/kidney_classification/pipeline/stage_03_model_training.py
+      - config/config.yaml
+      - artifacts/data_ingestion/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone
+      - artifacts/prepare_base_model
+    params:
+      - IMAGE_SIZE
+      - BATCH_SIZE
+      - EPOCHS
+    outs:
+      - artifacts/training/model.h5
+
+  evaluation:
+    cmd: python src/kidney_classification/pipeline/stage_04_model_evaluation_with_mlflow.py
+    deps:
+      - src/kidney_classification/pipeline/stage_04_model_evaluation_with_mlflow.py
+      - config/config.yaml
+      - artifacts/data_ingestion/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone
+      - artifacts/training/model.h5
+    params:
+      - IMAGE_SIZE
+      - BATCH_SIZE
+      - EPOCHS
+    metrics:
+      - scores.json:
+          cache: false

Kidney-Disease-Classifcation/main.py

@@ -0,0 +1,62 @@
+import sys
+
+sys.path.append("./src")
+from kidney_classification.pipeline.stage_04_model_evaluation_with_mlflow import (
+    EvaluationPipeline,
+)
+from kidney_classification.pipeline.stage_03_model_training import ModelTrainingPipeline
+from kidney_classification.pipeline.stage_02_prepare_base_model import (
+    PrepareBaseModelTrainingPipeline,
+)
+from kidney_classification.pipeline.stage_01_data_ingestion import (
+    DataIngestionTrainingPipeline,
+)
+from kidney_classification import logger
+
+
+STAGE_NAME = "Data Ingestion"
+
+try:
+    logger.info(f"-------------Running stage: {STAGE_NAME}-------------")
+    pipeline = DataIngestionTrainingPipeline()
+    pipeline.main()
+    logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+
+STAGE_NAME = "Prepare base model"
+
+try:
+    logger.info(f"-------------Running stage: {STAGE_NAME}-------------")
+    pipeline = PrepareBaseModelTrainingPipeline()
+    pipeline.main()
+    logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+
+STAGE_NAME = "Training Model"
+
+try:
+    logger.info(f"-------------Running stage: {STAGE_NAME}-------------")
+    pipeline = ModelTrainingPipeline()
+    pipeline.main()
+    logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+except Exception as e:
+    logger.exception(e)
+    raise e
+
+
+STAGE_NAME = "Evaluation Stage"
+
+try:
+    logger.info(f"-------------Running stage: {STAGE_NAME}-------------")
+    pipeline = EvaluationPipeline()
+    pipeline.main()
+    logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+except Exception as e:
+    logger.exception(e)
+    raise e

Kidney-Disease-Classifcation/model/model.h5

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

Kidney-Disease-Classifcation/params.yaml

@@ -0,0 +1,6 @@
+IMAGE_SIZE: [150, 150, 3]
+BATCH_SIZE: 32
+INCLUDE_TOP: False
+EPOCHS: 15
+CLASSES: 4
+WEIGHTS: imagenet

Kidney-Disease-Classifcation/requirements.txt

@@ -0,0 +1,18 @@
+tensorflow==2.15.0.post1
+pandas==2.1.4
+dvc==3.35.0
+mlflow==2.9.2
+notebook==7.0.6
+numpy==1.26.2
+matplotlib==3.8.2
+seaborn==0.13.0
+python-box==7.1.1
+PyYAML==6.0.1
+tqdm==4.66.1
+ensure==1.0.4
+joblib==1.3.2
+types-PyYAML==6.0.12.12
+scipy==1.11.4
+Flask==3.0.0
+Flask-Cors==4.0.0
+gdown==4.7.1

Kidney-Disease-Classifcation/research/01_data_ingestion.ipynb

@@ -0,0 +1,252 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation/src'"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir('../')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation'"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from pathlib import Path\n",
+    "\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": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from kidney_classification.constants import *\n",
+    "from kidney_classification.utils.common import read_yaml, create_directories"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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.artifacts_root])\n",
+    "\n",
+    "    def get_data_ingestion_config(self) -> DataIngestionConfig:\n",
+    "        config = self.config.data_ingestion\n",
+    "\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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import zipfile\n",
+    "import gdown\n",
+    "from kidney_classification import logger"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class DataIngestion:\n",
+    "    def __init__(self, config: DataIngestionConfig):\n",
+    "        self.config = config\n",
+    "\n",
+    "    def download_file(self) -> str:\n",
+    "        '''\n",
+    "        Fetch data from the url\n",
+    "        '''\n",
+    "\n",
+    "        try:\n",
+    "            dataset_url = self.config.source_URL\n",
+    "            zip_download_dir = self.config.local_data_file\n",
+    "            os.makedirs(\"artifacts/data_ingestion\", exist_ok=True)\n",
+    "            logger.info(\n",
+    "                f\"Downloading data from {dataset_url} into file {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",
+    "\n",
+    "            logger.info(\n",
+    "                f\"Downloaded data from {dataset_url} into file {zip_download_dir}\")\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            raise e\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": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2023-12-23 01:06:36,655: INFO: common yaml file: config/config.yaml loaded successfully]\n",
+      "[2023-12-23 01:06:36,656: INFO: common yaml file: params.yaml loaded successfully]\n",
+      "[2023-12-23 01:06:36,657: INFO: common created directory at: artifacts]\n",
+      "[2023-12-23 01:06:36,658: INFO: common created directory at: artifacts/data_ingestion]\n",
+      "[2023-12-23 01:06:36,659: INFO: 986331348 Downloading data from https://drive.google.com/file/d/1CGXriP_nlctsaWVbz0W3mFdPK05lQmHK/view?usp=sharing into file artifacts/data_ingestion/data.zip]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Downloading...\n",
+      "From (uriginal): https://drive.google.com/uc?/export=download&id=1CGXriP_nlctsaWVbz0W3mFdPK05lQmHK\n",
+      "From (redirected): https://drive.google.com/uc?/export=download&id=1CGXriP_nlctsaWVbz0W3mFdPK05lQmHK&confirm=t&uuid=3aeb0b9b-c680-4ec4-a1ab-78891e4f5025\n",
+      "To: /home/shrey/Desktop/Kidney-Disease-Classifcation/artifacts/data_ingestion/data.zip\n",
+      "100%|██████████| 1.63G/1.63G [02:31<00:00, 10.7MB/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2023-12-23 01:09:10,818: INFO: 986331348 Downloaded data from https://drive.google.com/file/d/1CGXriP_nlctsaWVbz0W3mFdPK05lQmHK/view?usp=sharing into file artifacts/data_ingestion/data.zip]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "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.extract_zip_file()\n",
+    "except Exception as e:\n",
+    "    raise e"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env",
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Kidney-Disease-Classifcation/research/02_prepare_base_model.ipynb

@@ -0,0 +1,281 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation'"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir(\"../\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir(\"src\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "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_include_top: bool\n",
+    "    params_weights: str\n",
+    "    params_classes: int"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from kidney_classification.constants import *\n",
+    "from kidney_classification.utils.common import read_yaml, create_directories"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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.artifacts_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_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": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.layers import Dense, Flatten, BatchNormalization, Dropout\n",
+    "from tensorflow.keras.models import Sequential"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class PrepareBaseModel:\n",
+    "    @staticmethod\n",
+    "    def prepare_full_model():\n",
+    "        VGG_model = Sequential()\n",
+    "\n",
+    "        pretrained_model= tf.keras.applications.VGG16(\n",
+    "            include_top=False,\n",
+    "            input_shape=(150, 150, 3),\n",
+    "            pooling='max',\n",
+    "            classes=4,\n",
+    "            weights='imagenet'\n",
+    "        )\n",
+    "\n",
+    "        VGG_model.add(pretrained_model)\n",
+    "        VGG_model.add(Flatten())\n",
+    "        VGG_model.add(Dense(512, activation='relu'))\n",
+    "        VGG_model.add(BatchNormalization())\n",
+    "        VGG_model.add(Dropout(0.5))\n",
+    "\n",
+    "        VGG_model.add(Dense(4, activation='softmax'))\n",
+    "        pretrained_model.trainable = False\n",
+    "\n",
+    "        VGG_model.compile(\n",
+    "            optimizer='adam',\n",
+    "            loss='sparse_categorical_crossentropy',\n",
+    "            metrics=['accuracy']\n",
+    "        )\n",
+    "\n",
+    "        return VGG_model\n",
+    "\n",
+    "    def update_base_model(self, config: PrepareBaseModelConfig):\n",
+    "        full_model = self.prepare_full_model()\n",
+    "\n",
+    "        full_model.summary()\n",
+    "        full_model.save(config.updated_base_model_path)\n",
+    "    \n",
+    "        \n",
+    "    @staticmethod\n",
+    "    def save_model(path: Path, model: tf.keras.Model):\n",
+    "        model.save(path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir(\"../\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-01-03 15:58:32,485: INFO: common yaml file: config/config.yaml loaded successfully]\n",
+      "[2024-01-03 15:58:32,487: INFO: common yaml file: params.yaml loaded successfully]\n",
+      "Model: \"sequential_3\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " vgg16 (Functional)          (None, 512)               14714688  \n",
+      "                                                                 \n",
+      " flatten_3 (Flatten)         (None, 512)               0         \n",
+      "                                                                 \n",
+      " dense_5 (Dense)             (None, 512)               262656    \n",
+      "                                                                 \n",
+      " batch_normalization_3 (Bat  (None, 512)               2048      \n",
+      " chNormalization)                                                \n",
+      "                                                                 \n",
+      " dropout_3 (Dropout)         (None, 512)               0         \n",
+      "                                                                 \n",
+      " dense_6 (Dense)             (None, 4)                 2052      \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 14981444 (57.15 MB)\n",
+      "Trainable params: 265732 (1.01 MB)\n",
+      "Non-trainable params: 14715712 (56.14 MB)\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    config = ConfigurationManager()\n",
+    "    prepare_base_model_config = config.get_prepare_base_model_config()\n",
+    "    prepare_base_model = PrepareBaseModel()\n",
+    "    prepare_base_model.update_base_model(prepare_base_model_config)\n",
+    "except Exception as e:\n",
+    "    raise e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env",
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Kidney-Disease-Classifcation/research/03_model_training.ipynb

@@ -0,0 +1,341 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation/research'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir(\"../\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from pathlib import Path\n",
+    "\n",
+    "\n",
+    "@dataclass(frozen=True)\n",
+    "class TrainingConfig:\n",
+    "    root_dir: Path\n",
+    "    trained_model_path: Path\n",
+    "    updated_base_model_path: Path\n",
+    "    training_data: Path\n",
+    "    params_epochs: int\n",
+    "    params_batch_size: int\n",
+    "    params_image_size: list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir(\"./src\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-01-03 15:58:59.001906: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-01-03 15:58:59.003769: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2024-01-03 15:58:59.032703: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2024-01-03 15:58:59.032753: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2024-01-03 15:58:59.033922: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2024-01-03 15:58:59.038705: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2024-01-03 15:58:59.039146: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2024-01-03 15:58:59.655806: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
+     ]
+    }
+   ],
+   "source": [
+    "from kidney_classification.constants import *\n",
+    "from kidney_classification.utils.common import read_yaml, create_directories\n",
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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.artifacts_root])\n",
+    "\n",
+    "\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, \"CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone\")\n",
+    "        create_directories([\n",
+    "            Path(training.root_dir)\n",
+    "        ])\n",
+    "\n",
+    "        training_config = TrainingConfig(\n",
+    "            root_dir=Path(training.root_dir),\n",
+    "            trained_model_path=Path(training.trained_model_path),\n",
+    "            updated_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_image_size=params.IMAGE_SIZE\n",
+    "        )\n",
+    "\n",
+    "        return training_config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Training:\n",
+    "    def __init__(self, config: TrainingConfig):\n",
+    "        self.config = config\n",
+    "\n",
+    "    \n",
+    "    def get_base_model(self):\n",
+    "        self.model = tf.keras.models.load_model(\n",
+    "            self.config.updated_base_model_path\n",
+    "        )\n",
+    "\n",
+    "    def train_valid_generator(self):\n",
+    "        img_height, img_width = self.config.params_image_size[:-1]\n",
+    "\n",
+    "        train = tf.keras.utils.image_dataset_from_directory(\n",
+    "            self.config.training_data,\n",
+    "            image_size=(img_height, img_width),\n",
+    "            validation_split=0.1,\n",
+    "            subset='training',\n",
+    "            seed=123\n",
+    "        )\n",
+    "        \n",
+    "        val = tf.keras.utils.image_dataset_from_directory(\n",
+    "            self.config.training_data,\n",
+    "            image_size=(img_height, img_width),\n",
+    "            validation_split=0.2,\n",
+    "            subset='validation',\n",
+    "            seed=123\n",
+    "        )\n",
+    "        train = train.map(lambda x, y: (x / 255, y))\n",
+    "        val = val.map(lambda x, y: (x / 255, y))\n",
+    "        AUTOTUNE = tf.data.AUTOTUNE\n",
+    "\n",
+    "        self.train_dataset = train.cache().prefetch(buffer_size=AUTOTUNE)\n",
+    "        self.val_dataset = val.cache().prefetch(buffer_size=AUTOTUNE)\n",
+    "\n",
+    "        \n",
+    "    @staticmethod\n",
+    "    def save_model(path: Path, model: tf.keras.Model):\n",
+    "        model.save(path)\n",
+    "\n",
+    "    \n",
+    "    def define_and_train_model(self):\n",
+    "\n",
+    "        self.model.fit(\n",
+    "            self.train_dataset,\n",
+    "            validation_data=self.val_dataset,\n",
+    "            epochs=self.config.params_epochs,\n",
+    "        )\n",
+    "\n",
+    "        self.save_model(\n",
+    "            path=self.config.trained_model_path,\n",
+    "            model=self.model\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir(\"../\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-01-03 15:59:11,299: INFO: common yaml file: config/config.yaml loaded successfully]\n",
+      "[2024-01-03 15:59:11,301: INFO: common yaml file: params.yaml loaded successfully]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-01-03 15:59:11.602362: E external/local_xla/xla/stream_executor/cuda/cuda_driver.cc:274] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-01-03 15:59:12,070: WARNING: optimizer Skipping variable loading for optimizer 'Adam', because it has 13 variables whereas the saved optimizer has 1 variables. ]\n",
+      "Found 12446 files belonging to 4 classes.\n",
+      "Using 11202 files for training.\n",
+      "Found 12446 files belonging to 4 classes.\n",
+      "Using 2489 files for validation.\n",
+      "Epoch 1/15\n",
+      "351/351 [==============================] - 561s 2s/step - loss: 0.5099 - accuracy: 0.8103 - val_loss: 0.2366 - val_accuracy: 0.9152\n",
+      "Epoch 2/15\n",
+      "351/351 [==============================] - 566s 2s/step - loss: 0.2120 - accuracy: 0.9229 - val_loss: 0.2941 - val_accuracy: 0.8803\n",
+      "Epoch 3/15\n",
+      "351/351 [==============================] - 571s 2s/step - loss: 0.1573 - accuracy: 0.9466 - val_loss: 0.0994 - val_accuracy: 0.9667\n",
+      "Epoch 4/15\n",
+      "351/351 [==============================] - 547s 2s/step - loss: 0.1370 - accuracy: 0.9528 - val_loss: 0.0742 - val_accuracy: 0.9787\n",
+      "Epoch 5/15\n",
+      "351/351 [==============================] - 552s 2s/step - loss: 0.1217 - accuracy: 0.9565 - val_loss: 0.0564 - val_accuracy: 0.9835\n",
+      "Epoch 6/15\n",
+      "351/351 [==============================] - 550s 2s/step - loss: 0.1064 - accuracy: 0.9621 - val_loss: 0.0626 - val_accuracy: 0.9791\n",
+      "Epoch 7/15\n",
+      "351/351 [==============================] - 550s 2s/step - loss: 0.1028 - accuracy: 0.9622 - val_loss: 0.0845 - val_accuracy: 0.9658\n",
+      "Epoch 8/15\n",
+      "351/351 [==============================] - 551s 2s/step - loss: 0.0953 - accuracy: 0.9655 - val_loss: 0.0527 - val_accuracy: 0.9811\n",
+      "Epoch 9/15\n",
+      "351/351 [==============================] - 526s 2s/step - loss: 0.0900 - accuracy: 0.9692 - val_loss: 0.0698 - val_accuracy: 0.9731\n",
+      "Epoch 10/15\n",
+      "351/351 [==============================] - 526s 1s/step - loss: 0.0806 - accuracy: 0.9708 - val_loss: 0.0454 - val_accuracy: 0.9867\n",
+      "Epoch 11/15\n",
+      "351/351 [==============================] - 529s 2s/step - loss: 0.0756 - accuracy: 0.9723 - val_loss: 0.0404 - val_accuracy: 0.9871\n",
+      "Epoch 12/15\n",
+      "351/351 [==============================] - 533s 2s/step - loss: 0.0762 - accuracy: 0.9723 - val_loss: 0.0458 - val_accuracy: 0.9867\n",
+      "Epoch 13/15\n",
+      "351/351 [==============================] - 538s 2s/step - loss: 0.0651 - accuracy: 0.9760 - val_loss: 0.0331 - val_accuracy: 0.9912\n",
+      "Epoch 14/15\n",
+      "351/351 [==============================] - 547s 2s/step - loss: 0.0740 - accuracy: 0.9746 - val_loss: 0.0726 - val_accuracy: 0.9771\n",
+      "Epoch 15/15\n",
+      "351/351 [==============================] - 562s 2s/step - loss: 0.0742 - accuracy: 0.9744 - val_loss: 0.0441 - val_accuracy: 0.9859\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/shrey/Desktop/Kidney-Disease-Classifcation/env/lib/python3.11/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"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    config = ConfigurationManager()\n",
+    "    training_config = config.get_training_config()\n",
+    "    training = Training(config=training_config)\n",
+    "    training.get_base_model()\n",
+    "    training.train_valid_generator()\n",
+    "    training.define_and_train_model()\n",
+    "    \n",
+    "except Exception as e:\n",
+    "    raise e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env",
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Kidney-Disease-Classifcation/research/04_model_evaluation_with_mlflow.ipynb

@@ -0,0 +1,346 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation/research'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir('../')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/home/shrey/Desktop/Kidney-Disease-Classifcation'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"MLFLOW_TRACKING_URI\"]=\"https://dagshub.com/Shrey-patel-07/Kidney-Disease-Classifcation.mlflow\"\n",
+    "os.environ[\"MLFLOW_TRACKING_USERNAME\"]=\"Shrey-patel-07\"\n",
+    "os.environ[\"MLFLOW_TRACKING_PASSWORD\"]=\"6a425a20bb5b645c5efa1ca49ab28097a92a76ee\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-01-04 12:24:18.257148: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-01-04 12:24:18.258826: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2024-01-04 12:24:18.285564: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2024-01-04 12:24:18.285595: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2024-01-04 12:24:18.286297: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2024-01-04 12:24:18.290364: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2024-01-04 12:24:18.290802: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2024-01-04 12:24:18.864121: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
+     ]
+    }
+   ],
+   "source": [
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-01-04 12:24:20.808055: E external/local_xla/xla/stream_executor/cuda/cuda_driver.cc:274] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = tf.keras.models.load_model('artifacts/training/model.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir('src/')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from kidney_classification.constants import *\n",
+    "from kidney_classification.utils.common import read_yaml, create_directories, save_json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ConfigurationManager:\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        config_filepath=CONFIG_FILE_PATH,\n",
+    "        param_filepath=PARAMS_FILE_PATH\n",
+    "    ):\n",
+    "        self.config = read_yaml(config_filepath)\n",
+    "        self.params = read_yaml(param_filepath)\n",
+    "        create_directories([self.config.artifacts_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/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone\",\n",
+    "            mlflow_uri=\"https://dagshub.com/Shrey-patel-07/Kidney-Disease-Classifcation.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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import mlflow\n",
+    "import mlflow.keras\n",
+    "from urllib.parse import urlparse"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Evaluation:\n",
+    "    def __init__(self, config: EvaluationConfig):\n",
+    "        self.config = config\n",
+    "        self.valid_generator = None  # Initialize to None\n",
+    "\n",
+    "    def _valid_generator(self):\n",
+    "        img_height, img_width = self.config.params_image_size[:-1]\n",
+    "\n",
+    "        self.valid_generator = tf.keras.utils.image_dataset_from_directory(\n",
+    "            self.config.training_data,\n",
+    "            image_size=(img_height, img_width),\n",
+    "            validation_split=0.30,\n",
+    "            subset='validation',\n",
+    "            seed=123\n",
+    "        )\n",
+    "\n",
+    "        self.valid_generator = self.valid_generator.map(lambda x, y: (x / 255, y))\n",
+    "        AUTOTUNE = tf.data.AUTOTUNE\n",
+    "        self.valid_generator = self.valid_generator.cache().prefetch(buffer_size=AUTOTUNE)\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 = self.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",
+    "                mlflow.keras.log_model(self.model, \"model\", registered_model_name=\"VGG16Model\")\n",
+    "            else:\n",
+    "                mlflow.keras.log_model(self.model, \"model\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.chdir('../')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2024-01-04 12:24:51,908: INFO: common yaml file: config/config.yaml loaded successfully]\n",
+      "[2024-01-04 12:24:51,910: INFO: common yaml file: params.yaml loaded successfully]\n",
+      "Found 12446 files belonging to 1 classes.\n",
+      "Using 3733 files for validation.\n",
+      "117/117 [==============================] - 147s 1s/step - loss: 3.2269e-06 - accuracy: 1.0000\n",
+      "[2024-01-04 12:27:19,911: INFO: common json file saved at: scores.json]\n",
+      "[2024-01-04 12:27:19,912: INFO: common json file saved at: scores.json]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024/01/04 12:27:22 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": [
+      "INFO:tensorflow:Assets written to: /tmp/tmpdrlg6a4p/model/data/model/assets\n",
+      "[2024-01-04 12:27:23,234: INFO: builder_impl Assets written to: /tmp/tmpdrlg6a4p/model/data/model/assets]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/shrey/Desktop/Kidney-Disease-Classifcation/env/lib/python3.11/site-packages/_distutils_hack/__init__.py:33: UserWarning: Setuptools is replacing distutils.\n",
+      "  warnings.warn(\"Setuptools is replacing distutils.\")\n",
+      "Registered model 'VGG16Model' already exists. Creating a new version of this model...\n",
+      "2024/01/04 12:27:47 INFO mlflow.store.model_registry.abstract_store: Waiting up to 300 seconds for model version to finish creation. Model name: VGG16Model, version 3\n",
+      "Created version '3' 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": "env",
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Kidney-Disease-Classifcation/research/trials.ipynb

@@ -0,0 +1,91 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gdown"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "url = \"https://drive.google.com/file/d/1CGXriP_nlctsaWVbz0W3mFdPK05lQmHK/view?usp=sharing\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "file_id = url.split(\"/\")[-2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Downloading...\n",
+      "From (uriginal): https://drive.google.com/uc?export=download&id=1CGXriP_nlctsaWVbz0W3mFdPK05lQmHK\n",
+      "From (redirected): https://drive.google.com/uc?export=download&id=1CGXriP_nlctsaWVbz0W3mFdPK05lQmHK&confirm=t&uuid=17666f87-2ddb-4a4f-a8fb-421ff82803bd\n",
+      "To: /home/shrey/Desktop/Kidney-Disease-Classifcation/research/kidney-CT-scan.zip\n",
+      "100%|██████████| 1.63G/1.63G [07:37<00:00, 3.56MB/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'kidney-CT-scan.zip'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prefix = \"https://drive.google.com/uc?export=download&id=\"\n",
+    "gdown.download(prefix + file_id, \"kidney-CT-scan.zip\", quiet=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env",
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Kidney-Disease-Classifcation/scores.json

@@ -0,0 +1,4 @@
+{
+    "loss": 0.013196375221014023,
+    "accuracy": 0.996370255947113
+}

Kidney-Disease-Classifcation/setup.py

@@ -0,0 +1,27 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+__version__ = "0.0.1"
+
+REPO_NAME = "Kidney-Disease-Classification"
+AUTHOR_NAME = "Shrey-patel-07"
+SRC_REPO = "kidney_classification"
+AUTHOR_EMAIL = "shrey07patel@gmail.com"
+
+setuptools.setup(
+    name=SRC_REPO,
+    version=__version__,
+    author=AUTHOR_NAME,
+    author_email=AUTHOR_EMAIL,
+    description="A small package for kidney disease classification",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url=f"https://github.com/{AUTHOR_NAME}/{REPO_NAME}",
+    project_urls={
+        "Bug Tracker": f"https://github.com/{AUTHOR_NAME}/{REPO_NAME}/issues",
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+)

Kidney-Disease-Classifcation/src/kidney_classification/__init__.py

@@ -0,0 +1,18 @@
+import os
+import sys
+import logging
+
+logging_str = "[%(asctime)s: %(levelname)s: %(module)s %(message)s]"
+
+__name__ = "kidney_classification"
+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(__name__)

Kidney-Disease-Classifcation/src/kidney_classification/components/data_ingestion.py

@@ -0,0 +1,45 @@
+import os
+import zipfile
+import gdown
+from kidney_classification import logger
+from kidney_classification.entity.config_entity import DataIngestionConfig
+
+
+class DataIngestion:
+    def __init__(self, config: DataIngestionConfig):
+        self.config = config
+
+    def download_file(self) -> str:
+        """
+        Fetch data from the url
+        """
+
+        try:
+            dataset_url = self.config.source_URL
+            zip_download_dir = self.config.local_data_file
+            os.makedirs("artifacts/data_ingestion", exist_ok=True)
+            logger.info(
+                f"Downloading data from {dataset_url} into file {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 file {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)

Kidney-Disease-Classifcation/src/kidney_classification/components/model_evaluation_mlflow.py

@@ -0,0 +1,59 @@
+import tensorflow as tf
+from urllib.parse import urlparse
+import mlflow
+import mlflow.keras
+from pathlib import Path
+from kidney_classification.utils.common import save_json
+from kidney_classification.entity.config_entity import EvaluationConfig
+
+
+class Evaluation:
+    def __init__(self, config: EvaluationConfig):
+        self.config = config
+        self.valid_generator = None  # Initialize to None
+
+    def _valid_generator(self):
+        img_height, img_width = self.config.params_image_size[:-1]
+
+        self.valid_generator = tf.keras.utils.image_dataset_from_directory(
+            self.config.training_data,
+            image_size=(img_height, img_width),
+            validation_split=0.30,
+            subset="validation",
+            seed=123,
+        )
+
+        self.valid_generator = self.valid_generator.map(lambda x, y: (x / 255, y))
+        AUTOTUNE = tf.data.AUTOTUNE
+        self.valid_generator = self.valid_generator.cache().prefetch(
+            buffer_size=AUTOTUNE
+        )
+
+    @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 = self.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":
+                mlflow.keras.log_model(
+                    self.model, "model", registered_model_name="VGG16Model"
+                )
+            else:
+                mlflow.keras.log_model(self.model, "model")

Kidney-Disease-Classifcation/src/kidney_classification/components/model_training.py

@@ -0,0 +1,49 @@
+import tensorflow as tf
+from pathlib import Path
+from kidney_classification.entity.config_entity import TrainingConfig
+
+
+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):
+        img_height, img_width = self.config.params_image_size[:-1]
+
+        train = tf.keras.utils.image_dataset_from_directory(
+            self.config.training_data,
+            image_size=(img_height, img_width),
+            validation_split=0.1,
+            subset="training",
+            seed=123,
+        )
+
+        val = tf.keras.utils.image_dataset_from_directory(
+            self.config.training_data,
+            image_size=(img_height, img_width),
+            validation_split=0.2,
+            subset="validation",
+            seed=123,
+        )
+        train = train.map(lambda x, y: (x / 255, y))
+        val = val.map(lambda x, y: (x / 255, y))
+        AUTOTUNE = tf.data.AUTOTUNE
+
+        self.train_dataset = train.cache().prefetch(buffer_size=AUTOTUNE)
+        self.val_dataset = val.cache().prefetch(buffer_size=AUTOTUNE)
+
+    @staticmethod
+    def save_model(path: Path, model: tf.keras.Model):
+        model.save(path)
+
+    def define_and_train_model(self):
+        self.model.fit(
+            self.train_dataset,
+            validation_data=self.val_dataset,
+            epochs=self.config.params_epochs,
+        )
+
+        self.save_model(path=self.config.trained_model_path, model=self.model)

Kidney-Disease-Classifcation/src/kidney_classification/components/prepare_base_model.py

@@ -0,0 +1,46 @@
+import tensorflow as tf
+from pathlib import Path
+from kidney_classification.entity.config_entity import PrepareBaseModelConfig
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Flatten, BatchNormalization, Dropout
+
+
+class PrepareBaseModel:
+    @staticmethod
+    def prepare_full_model():
+        VGG_model = Sequential()
+
+        pretrained_model = tf.keras.applications.VGG16(
+            include_top=False,
+            input_shape=(150, 150, 3),
+            pooling="max",
+            classes=4,
+            weights="imagenet",
+        )
+
+        VGG_model.add(pretrained_model)
+        VGG_model.add(Flatten())
+        VGG_model.add(Dense(512, activation="relu"))
+        VGG_model.add(BatchNormalization())
+        VGG_model.add(Dropout(0.5))
+
+        VGG_model.add(Dense(4, activation="softmax"))
+        pretrained_model.trainable = False
+
+        VGG_model.compile(
+            optimizer="adam",
+            loss="sparse_categorical_crossentropy",
+            metrics=["accuracy"],
+        )
+
+        return VGG_model
+
+    def update_base_model(self, config: PrepareBaseModelConfig):
+        full_model = self.prepare_full_model()
+
+        full_model.summary()
+        full_model.save(config.updated_base_model_path)
+
+    @staticmethod
+    def save_model(path: Path, model: tf.keras.Model):
+        model.save(path)

Kidney-Disease-Classifcation/src/kidney_classification/config/configuration.py

@@ -0,0 +1,83 @@
+import os
+from kidney_classification.constants import *
+from kidney_classification.utils.common import read_yaml, create_directories, save_json
+from kidney_classification.entity.config_entity import (
+    DataIngestionConfig,
+    PrepareBaseModelConfig,
+    TrainingConfig,
+    EvaluationConfig,
+)
+
+
+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.artifacts_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_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,
+            "CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone",
+        )
+        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_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/CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone",
+            mlflow_uri="https://dagshub.com/Shrey-patel-07/Kidney-Disease-Classifcation.mlflow",
+            all_params=self.params,
+            params_image_size=self.params.IMAGE_SIZE,
+            params_batch_size=self.params.BATCH_SIZE,
+        )
+        return eval_config

Kidney-Disease-Classifcation/src/kidney_classification/constants/__init__.py

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

Kidney-Disease-Classifcation/src/kidney_classification/entity/config_entity.py

@@ -0,0 +1,42 @@
+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_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_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

Kidney-Disease-Classifcation/src/kidney_classification/pipeline/prediction.py

@@ -0,0 +1,31 @@
+import numpy as np
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+import os
+
+
+class PredictionPipeline:
+    def __init__(self, filename):
+        self.filename = filename
+
+    def predict(self):
+        model = load_model(os.path.join("model", "model.h5"))
+
+        imagename = self.filename
+        test_image = image.load_img(imagename, target_size=(150, 150))
+        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)
+
+        if result[0] == 0:
+            prediction = "Cyst"
+            return [{"image": prediction}]
+        elif result[0] == 1:
+            prediction = "Normal"
+            return [{"image": prediction}]
+        elif result[0] == 2:
+            prediction = "Stone"
+            return [{"image": prediction}]
+        else:
+            prediction = "Tumor"
+            return [{"image": prediction}]

Kidney-Disease-Classifcation/src/kidney_classification/pipeline/stage_01_data_ingestion.py

@@ -0,0 +1,31 @@
+import sys
+
+sys.path.append("./src")
+from kidney_classification.config.configuration import ConfigurationManager
+from kidney_classification.components.data_ingestion import DataIngestion
+from kidney_classification import logger
+
+STAGE_NAME = "Data Ingestion"
+
+
+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"-------------Running stage: {STAGE_NAME}-------------")
+        pipeline = DataIngestionTrainingPipeline()
+        pipeline.main()
+        logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+    except Exception as e:
+        logger.exception(e)
+        raise e

Kidney-Disease-Classifcation/src/kidney_classification/pipeline/stage_02_prepare_base_model.py

@@ -0,0 +1,30 @@
+import sys
+
+sys.path.append("./src")
+from kidney_classification.config.configuration import ConfigurationManager
+from kidney_classification.components.prepare_base_model import PrepareBaseModel
+from kidney_classification 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()
+        prepare_base_model.update_base_model(prepare_base_model_config)
+
+
+if __name__ == "__main__":
+    try:
+        logger.info(f"-------------Running stage: {STAGE_NAME}-------------")
+        pipeline = PrepareBaseModelTrainingPipeline()
+        pipeline.main()
+        logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+    except Exception as e:
+        logger.exception(e)
+        raise e

Kidney-Disease-Classifcation/src/kidney_classification/pipeline/stage_03_model_training.py

@@ -0,0 +1,32 @@
+import sys
+
+sys.path.append("./src")
+from kidney_classification.config.configuration import ConfigurationManager
+from kidney_classification.components.model_training import Training
+from kidney_classification import logger
+
+STAGE_NAME = "Training Model"
+
+
+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.define_and_train_model()
+
+
+if __name__ == "__main__":
+    try:
+        logger.info(f"-------------Running stage: {STAGE_NAME}-------------")
+        pipeline = ModelTrainingPipeline()
+        pipeline.main()
+        logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+    except Exception as e:
+        logger.exception(e)
+        raise e

Kidney-Disease-Classifcation/src/kidney_classification/pipeline/stage_04_model_evaluation_with_mlflow.py

@@ -0,0 +1,32 @@
+import sys
+
+sys.path.append("./src")
+from kidney_classification.config.configuration import ConfigurationManager
+from kidney_classification.components.model_evaluation_mlflow import Evaluation
+from kidney_classification import logger
+
+
+STAGE_NAME = "Evaluation Stage"
+
+
+class EvaluationPipeline:
+    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"-------------Running stage: {STAGE_NAME}-------------")
+        pipeline = EvaluationPipeline()
+        pipeline.main()
+        logger.info(f"-------------Stage: {STAGE_NAME} completed-------------")
+    except Exception as e:
+        logger.exception(e)
+        raise e

Kidney-Disease-Classifcation/src/kidney_classification/utils/common.py

@@ -0,0 +1,79 @@
+import os
+import json
+import yaml
+import base64
+import joblib
+from typing import Any
+from pathlib import Path
+from box import ConfigBox
+from ensure import ensure_annotations
+from box.exceptions import BoxValueError
+from kidney_classification import logger
+
+
+@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:
+        if not os.path.exists(path):
+            os.makedirs(path)
+            if verbose:
+                logger.info(f"created directory at: {path}")
+        else:
+            continue
+
+
+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.b64encode(f.read())
+
+
+@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}")

Kidney-Disease-Classifcation/templates.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+import logging
+
+# logging string
+logging.basicConfig(level=logging.INFO, format="[%(asctime)s]: %(message)s:")
+
+project_name = "kidney_classification"
+
+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}/constants/__init__.py",
+    "config/config.yaml",
+    "dvc.yaml",
+    "params.yaml",
+    "requirements.txt",
+    "setup.py",
+    "research/trials.ipynb",
+    "templates/index.html",
+]
+
+
+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 empty file: {filepath}")
+
+    else:
+        logging.info(f"{filename} is already exists")

Kidney-Disease-Classifcation/templates/index.html

@@ -0,0 +1,353 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>Kidney Disease Classification</title>
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
+        integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css" />
+    <style>
+        body {
+            background-color: #eff2f9;
+        }
+
+        .iupload h3 {
+            color: #1b2d6b;
+            font-size: 30px;
+            font-weight: 700;
+        }
+
+        .img-part {
+            height: 300px;
+            width: 300px;
+            margin: 0px auto;
+        }
+
+        .image-part {
+            height: 300px;
+            width: 300px;
+            border: 1px solid #1b2d6b;
+        }
+
+        .image-part img {
+            position: absolute;
+            height: 300px;
+            width: 300px;
+            display: none;
+            padding: 5px;
+        }
+
+        .image-part #video {
+            display: block;
+            height: 300px;
+            width: 300px;
+            padding: 5px;
+        }
+
+        .res-part {
+            border: 1px solid #dedede;
+            margin-left: 20px;
+            height: 310px;
+            width: 100%;
+            padding: 5px;
+            margin: 0px auto;
+            overflow: auto;
+        }
+
+        .res-part2 {
+            border: 1px solid #dedede;
+            height: 310px;
+            width: 100%;
+            padding: 5px;
+            margin: 0px auto;
+        }
+
+        .resp-img {
+            height: 298px;
+            width: 233px;
+            margin: 0px auto;
+        }
+
+        .jsonRes {
+            margin-left: 30px;
+        }
+
+        #send {
+            cursor: pointer;
+        }
+
+        .btn-part {
+            width: 325px;
+        }
+
+        textarea,
+        select,
+        .form-control,
+        .custom-select,
+        button.btn,
+        .btn-primary,
+        input[type="text"],
+        input[type="url"],
+        .uneditable-input {
+            border: 1px solid #363e75;
+            outline: 0 !important;
+            border-radius: 0px;
+            box-shadow: none;
+            -webkit-box-shadow: none;
+            -moz-box-shadow: none;
+        }
+
+        textarea:focus,
+        select:focus,
+        .form-control:focus,
+        .btn:focus,
+        .btn-primary:focus,
+        .custom-select:focus,
+        input[type="text"]:focus,
+        .uneditable-input:focus {
+            border: 1px solid #007bff;
+            outline: 0 !important;
+            border-radius: 0px;
+            box-shadow: none;
+            -webkit-box-shadow: none;
+            -moz-box-shadow: none;
+        }
+
+        #loading {
+            position: fixed;
+            left: 0px;
+            top: 0px;
+            width: 100%;
+            height: 100%;
+            z-index: 9999999999;
+            overflow: hidden;
+            background: rgba(255, 255, 255, 0.7);
+        }
+
+        .loader {
+            border: 8px solid #f3f3f3;
+            border-top: 8px solid #363e75;
+            border-radius: 50%;
+            width: 60px;
+            height: 60px;
+            left: 50%;
+            margin-left: -4em;
+            display: block;
+            animation: spin 2s linear infinite;
+        }
+
+        .loader,
+        .loader:after {
+            display: block;
+            position: absolute;
+            top: 50%;
+            margin-top: -4.05em;
+        }
+
+        @keyframes spin {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+
+        .right-part {
+            border: 1px solid #dedede;
+            padding: 5px;
+        }
+
+        .socials {
+            position: fixed;
+            bottom: 20px;
+            left: 0;
+            width: 100%;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        .icons {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+
+        .icons a {
+            margin: 0 10px;
+            color: #333;
+            font-size: 24px;
+        }
+
+        .credit {
+            position: absolute;
+            bottom: 0;
+            left: 10px;
+            color: #333;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="main container">
+        <section class="iupload">
+            <h3 class="text-center py-4">Object Classification</h3>
+            <div class="row">
+                <div class="img-part col-md-6">
+                    <div class="image-part">
+                        <video autoplay id="video"
+                            poster="https://img.freepik.com/free-vector/group-young-people-posing-photo_52683-18824.jpg?size=338&ext=jpg"></video>
+                        <img src="" id="photo">
+                        <canvas style="display:none;" id="canvas"></canvas>
+                    </div>
+                    <div class="btn-part">
+                        <form id="upload-data pt-3" class="">
+                            <div class="input-group mt-3 row">
+                                <button type="button" class="btn btn-primary col-md-5 col-xs-5 ml-3 mr-4"
+                                    id="uload">Upload</button>
+                                <button id="send" type="button"
+                                    class="btn btn-success col-md-5 col-xs-5">Predict</button>
+                            </div>
+
+                            <input type="hidden" class="form-control mr-2" id="url" placeholder="Enter REST Api url..."
+                                value="../predict" />
+                            <input name="upload" type="file" id="fileinput"
+                                style="position:absolute;top:-500px;" /><br />
+                        </form>
+                    </div>
+                </div>
+                <div class="col-md-6 col-xs-12 right-part">
+                    <h5 class="mb-2">
+                        <center>Prediction Results</center>
+                    </h5>
+                    <div class="row">
+                        <div class="res-part col-md-5 col-xs-12">
+                            <div class="jsonRes"></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </section>
+    </div>
+    <div class="socials">
+        <div class="credit">Designed by Shrey Patel</div>
+        <div class="icons">
+            <a href="https://www.linkedin.com/in/shreypatel07" target="_blank">
+                <i class="fab fa-linkedin"></i>
+            </a>
+            <a href="https://github.com/Shrey-patel-07" target="_blank">
+                <i class="fab fa-github"></i>
+            </a>
+            <a href="https://x.com/Shrey_Patel_07" target="_blank">
+                <i class="fab fa-twitter"></i>
+            </a>
+        </div>
+    </div>
+
+
+    <div id="loading">
+        <div class="loader"></div>
+    </div>
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"
+        integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
+        crossorigin="anonymous"></script>
+    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
+        integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
+        crossorigin="anonymous"></script>
+
+    <script>
+        var mybtn = document.getElementById('startbtn');
+        var myvideo = document.getElementById('video');
+        var mycanvas = document.getElementById('canvas');
+        var myphoto = document.getElementById('photo');
+        var base_data = "";
+
+        function sendRequest(base64Data) {
+            var type = "json";
+            if (base64Data != "" || base64Data != null) {
+                if (type == "imgtobase") {
+                    $(".res-part").html("");
+                    $(".res-part").html(base64Data);
+                }
+                else if (type == "basetoimg") {
+                    var imageData = $("#imgstring").val();
+                    $(".res-part").html("");
+                    $(".res-part").append("<img src='data:image/jpeg;base64," + imageData + "' alt='' />");
+                }
+                else {
+                    var url = $("#url").val();
+                    $("#loading").show();
+                    $.ajax({
+                        url: url,
+                        type: "post",
+                        cache: false,
+                        async: true,
+                        crossDomain: true,
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Access-Control-Allow-Origin': '*'
+                        },
+                        data: JSON.stringify({ image: base64Data }),
+                        success: function (res) {
+                            $(".res-part").html("");
+                            $(".res-part2").html("");
+                            try {
+                                var imageData = res[1].image;
+                                if (imageData.length > 100) {
+                                    if (imageData.length > 10) { $(".res-part2").append("<img class='resp-img' src='data:image/jpeg;base64," + imageData + "' alt='' />"); }
+                                }
+                            } catch (e) { }
+                            $(".res-part").html("<pre>" + res[0].image + "</pre>");
+                            $("#loading").hide();
+                        }
+                    });
+                }
+            }
+        }
+
+        $(document).ready(function () {
+            $("#loading").hide();
+
+            $('#send').click(function (evt) {
+                sendRequest(base_data);
+            });
+
+            $('#uload').click(function (evt) {
+                $('#fileinput').focus().trigger('click');
+            });
+            $("#fileinput").change(function () {
+                if (this.files && this.files[0]) {
+                    var reader = new FileReader();
+                    reader.onload = function (e) {
+                        var url = e.target.result;
+                        var img = new Image();
+                        img.crossOrigin = 'Anonymous';
+                        img.onload = function () {
+                            var canvas = document.createElement('CANVAS');
+                            var ctx = canvas.getContext('2d');
+                            canvas.height = this.height;
+                            canvas.width = this.width;
+                            ctx.drawImage(this, 0, 0);
+                            base_data = canvas.toDataURL('image/jpeg', 1.0).replace(/^data:image.+;base64,/, '');
+                            canvas = null;
+                        };
+                        img.src = url;
+                        $('#photo').attr('src', url);
+                        $('#photo').show();
+                        $('#video').hide();
+                    }
+                    reader.readAsDataURL(this.files[0]);
+                }
+            });
+        });
+
+    </script>
+</body>
+
+</html>