Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

README.md

@@ -1,12 +1,6 @@
 ---
-title: Acne Grading
-emoji: 👀
-colorFrom: red
-colorTo: pink
+title: acne_grading
+app_file: gradio_test.py
 sdk: gradio
 sdk_version: 3.41.2
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

base.py

@@ -0,0 +1,27 @@
+
+
+from enum import Enum
+
+class TrainingObjective(Enum):
+    CLASSIFICATION = 0
+    REGRESSION = 1
+
+class ModelBackbone(Enum):
+    INCEPTION_V3 = 0
+    EFFICIENT_NET_B0 = 1
+    MOBILE_NET_V3_LARGE = 2
+
+
+class TransformationType(Enum):
+    RESIZE = 0
+    TO_TENSOR = 1
+    RANDOM_HORIZONTAL_FLIP = 2
+    NORMALIZE = 3
+    RANDOM_ROTATION = 4
+    RANDOM_CLIP = 5
+
+model_input_dict = {
+    ModelBackbone.INCEPTION_V3: (299, 299),
+    ModelBackbone.EFFICIENT_NET_B0: (224, 224),
+    ModelBackbone.MOBILE_NET_V3_LARGE: (224, 224)
+}

config.py

@@ -0,0 +1,28 @@
+
+from base import TrainingObjective, ModelBackbone, model_input_dict, TransformationType
+
+DATASET_PATH = '/Users/suyashharlalka/Documents/workspace/gabit/acne_classification/dataset/Classification/JPEGImages'
+MODEL_DIR = '/Users/suyashharlalka/Documents/workspace/gabit/acne_classification/model'
+
+MODEL_OBJECTIVE =  TrainingObjective.REGRESSION
+MODEL_BACKBONE = ModelBackbone.EFFICIENT_NET_B0
+MODEL_INPUT_SIZE = model_input_dict[MODEL_BACKBONE]
+TRANSFORMS_TO_APPLY = [
+    TransformationType.RESIZE.name, 
+    TransformationType.TO_TENSOR.name,
+    TransformationType.RANDOM_HORIZONTAL_FLIP.name,
+    TransformationType.NORMALIZE.name
+]
+NUM_CLASSES = 4
+LAST_N_LAYERS_TO_TRAIN = 5
+EPOCHS = 20
+MODEL_TRAINING = True
+IS_LIMITED = False
+BATCH_SIZE = 64
+SHUFFLE = True
+NUM_WORKERS = 0
+
+BASE_LR = 0.001
+LR_DECAY_STEP_SIZE = 5
+LR_DECAY_GAMMA = 0.1
+

dataset.py

@@ -0,0 +1,30 @@
+
+import os 
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from PIL import Image
+
+class AcneDataset(Dataset):
+    def __init__(self, dataDir, limit=True, transform=None):
+        self.dataDir = dataDir
+        self.image_names = os.listdir(self.dataDir)
+        self.image_names = [os.path.join(self.dataDir, x) for x in self.image_names]
+        self.image_names = [x for x in self.image_names if x.endswith('.jpg')]
+        self.image_names = sorted(self.image_names)
+        self.transform = transform
+        if limit:
+            self.image_names = self.image_names[1000:1200]
+        
+    def __len__(self):
+        return len(self.image_names)
+    
+    def __getitem__(self, idx):
+        imgName = self.image_names[idx]
+        label = imgName.split('/')[-1].split('.')[0].split('_')[0][-1]
+        label = int(label)
+        label = np.array(label).astype(np.float32)
+        img = Image.open(imgName)
+        if self.transform:
+            img = self.transform(img)
+        return img, label

flagged/log.csv

@@ -0,0 +1,2 @@
+input_img,output,flag,username,timestamp
+/Users/suyash.harlalka/Desktop/personal/acne_classification/code/flagged/input_img/a37df70aebf29843d866a7ad396a79ce94debfbd/tmpvvjl4871.jpg,/Users/suyash.harlalka/Desktop/personal/acne_classification/code/flagged/output/c1b5617618b88e89a6daa275fa1df7a05106d635/tmpdb5o51or.png,,,2023-08-31 17:29:17.512316

gradio_test.py

@@ -0,0 +1,115 @@
+import numpy as np
+import gradio as gr
+from base import TrainingObjective, ModelBackbone, model_input_dict, TransformationType
+import os 
+import json
+from utils import get_model_architecture, get_transforms_to_apply_, get_transforms_to_apply
+import torch
+from PIL import Image
+from torchvision import transforms
+from matplotlib import pyplot as plt
+from dataset import AcneDataset
+import config
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+
+curr_dir = os.path.dirname(os.path.abspath(__file__))
+#go up one level
+# curr_dir = os.path.dirname(curr_dir)
+model_dir = os.path.join(curr_dir, 'model')
+model_name = 'model_0'
+model_dir = os.path.join(model_dir, model_name)
+# model_dir = '/Users/suyashharlalka/Documents/workspace/gabit/acne_classification/model/model_0'
+model_config = os.path.join(model_dir, 'config.json')
+
+with open(model_config, 'r') as f:
+    config_json = json.load(f)
+
+model = get_model_architecture(config_json)
+model_path = os.path.join(model_dir, 'model.pth')
+model.load_state_dict(torch.load(model_path), map_location=torch.device('cpu'))
+
+testing_transform = config_json['TRANSFORMS_TO_APPLY']
+testing_transform = [TransformationType[transform] for transform in testing_transform if transform != 'RANDOM_HORIZONTAL_FLIP']
+testing_transform = [get_transforms_to_apply_(transform) for transform in testing_transform]
+testing_transform = transforms.Compose(testing_transform)
+
+# data_dir = config.DATASET_PATH
+# isLimited = config.IS_LIMITED
+# dataset = AcneDataset(data_dir, limit=isLimited)
+# dataset.transform = testing_transform
+# dataloader = DataLoader(dataset, batch_size=32, shuffle=False, num_workers=0)
+device = torch.device('cpu')
+
+def predict_acne(img):
+    img = testing_transform(img)
+    img = img.unsqueeze(0)
+    img = img.to(device)
+    output = model(img)
+    predicted = torch.round(output.data)
+    predicted = predicted.squeeze(1)
+    predicted = predicted.cpu().numpy()[0]
+    return predicted
+
+
+# img_dir = '/Users/suyash.harlalka/Desktop/personal/acne_classification/dataset/Classification/JPEGImages'
+# img_names = os.listdir(img_dir)
+# for name in img_names:
+#     if name.endswith('.jpg'):
+#         img_path = os.path.join(img_dir, name)
+#         img = Image.open(img_path)
+#         img = img.convert('RGB')
+#         print(predict_acne(img))
+
+correct = 0
+total = 0
+mainLabel = []
+predictedLabel = []
+model.to(device)
+model.eval()
+
+# for name in tqdm(img_names):
+#     if name.endswith('.jpg'):
+#         img_path = os.path.join(img_dir, name)
+#         img = Image.open(img_path)
+#         predicted = predict_acne(img)
+#         label = int(name.split('_')[0][-1])
+#         label = int(label)
+#         correct += (predicted == label).sum().item()
+#         mainLabel.append(label)
+#         predictedLabel.append(predicted)
+#         total += 1
+
+
+import gradio as gr
+
+
+gr.Interface(fn=predict_acne,
+             inputs=gr.Image(type="pil"),
+             outputs="number",
+            ).launch(
+                share=True,
+            )
+
+
+# for images, labels in tqdm(dataloader, desc="Processing", unit="batch"):
+#     images = images.to(device)
+#     labels = labels.to(device)
+#     outputs = model(images)
+#     # print('Outputs:{outputs}, label: {label}'.format(outputs=outputs, label=labels))
+
+#     predicted = torch.round(outputs.data)
+#     predicted = predicted.squeeze(1)
+#     total += labels.size(0)
+#     correct += (predicted == labels).sum().item()
+
+#     mainLabel.extend(labels.cpu().numpy())
+#     predictedLabel.extend(predicted.cpu().numpy())
+    
+# print(f'Accuracy of the network on the {total} test images: {100 * correct / total}%')
+
+
+
+
+

model/model_0/config.json

@@ -0,0 +1 @@
+{"DATASET_PATH": "/Users/suyash.harlalka/Desktop/personal/acne_classification/dataset/Classification/JPEGImages", "MODEL_DIR": "/Users/suyash.harlalka/Desktop/personal/acne_classification/model", "MODEL_OBJECTIVE": "REGRESSION", "MODEL_BACKBONE": "EFFICIENT_NET_B0", "MODEL_INPUT_SIZE": [224, 224], "TRANSFORMS_TO_APPLY": ["RESIZE", "TO_TENSOR", "RANDOM_HORIZONTAL_FLIP", "NORMALIZE"], "NUM_CLASSES": 4, "LAST_N_LAYERS_TO_TRAIN": 5, "EPOCHS": 10, "MODEL_TRAINING": true, "IS_LIMITED": false, "BATCH_SIZE": 64, "SHUFFLE": true, "NUM_WORKERS": 0, "BASE_LR": 0.001, "LR_DECAY_STEP_SIZE": 5, "LR_DECAY_GAMMA": 0.1, "LOSS": [0.6981074272290521, 0.2594577281371407, 0.16056970701269482, 0.12656819302102792, 0.10815351424009903, 0.10907206441397252, 0.08555250760653745, 0.07441781347860461, 0.07726245827001074, 0.0703853020525497], "EPOCHS_DONE": 10, "TRAINED_MODEL_DIR": "/Users/suyash.harlalka/Desktop/personal/acne_classification/model/model_0"}

model/model_0/model.pth

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

model/model_1/config.json

@@ -0,0 +1 @@
+{"DATASET_PATH": "/Users/suyash.harlalka/Desktop/personal/acne_classification/dataset/Classification/JPEGImages", "MODEL_DIR": "/Users/suyash.harlalka/Desktop/personal/acne_classification/model", "MODEL_OBJECTIVE": "REGRESSION", "MODEL_BACKBONE": "EFFICIENT_NET_B0", "MODEL_INPUT_SIZE": [224, 224], "TRANSFORMS_TO_APPLY": ["RESIZE", "TO_TENSOR", "RANDOM_HORIZONTAL_FLIP", "NORMALIZE"], "NUM_CLASSES": 4, "LAST_N_LAYERS_TO_TRAIN": 5, "EPOCHS": 10, "MODEL_TRAINING": true, "IS_LIMITED": false, "BATCH_SIZE": 64, "SHUFFLE": true, "NUM_WORKERS": 0, "BASE_LR": 0.001, "LR_DECAY_STEP_SIZE": 5, "LR_DECAY_GAMMA": 0.1, "LOSS": [0.8423960444174314, 0.2454124618517725, 0.16250047322950864, 0.15113061862556557, 0.12270178175286243, 0.0968482023791263, 0.10082359141425083, 0.07315939174670923, 0.06981939018556946, 0.06618086170209081], "EPOCHS_DONE": 10, "TRAINED_MODEL_DIR": "/Users/suyash.harlalka/Desktop/personal/acne_classification/model/model_1"}

model/model_1/model.pth

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

model/model_2/config.json

@@ -0,0 +1 @@
+{"DATASET_PATH": "/Users/suyash.harlalka/Desktop/personal/acne_classification/dataset/Classification/JPEGImages", "MODEL_DIR": "/Users/suyash.harlalka/Desktop/personal/acne_classification/model", "MODEL_OBJECTIVE": "REGRESSION", "MODEL_BACKBONE": "EFFICIENT_NET_B0", "MODEL_INPUT_SIZE": [224, 224], "TRANSFORMS_TO_APPLY": ["RESIZE", "TO_TENSOR", "RANDOM_HORIZONTAL_FLIP", "NORMALIZE"], "NUM_CLASSES": 4, "LAST_N_LAYERS_TO_TRAIN": 5, "EPOCHS": 20, "MODEL_TRAINING": true, "IS_LIMITED": false, "BATCH_SIZE": 64, "SHUFFLE": true, "NUM_WORKERS": 0, "BASE_LR": 0.001, "LR_DECAY_STEP_SIZE": 5, "LR_DECAY_GAMMA": 0.1, "LOSS": [0.7182596655268418, 0.28382997606929977, 0.21820551078570516, 0.16277591256718887, 0.11228116758559879, 0.11437285848354038, 0.11287243585837514, 0.10567777721505416], "EPOCHS_DONE": 8, "TRAINED_MODEL_DIR": "/Users/suyash.harlalka/Desktop/personal/acne_classification/model/model_2"}

model/model_2/model.pth

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

requirements.txt

@@ -0,0 +1,230 @@
+absl-py==1.4.0
+aiofiles==22.1.0
+aiohttp==3.8.4
+aiosignal==1.3.1
+aiosqlite==0.18.0
+altair==4.2.2
+antlr4-python3-runtime==4.9.3
+anyio==3.6.2
+APScheduler==3.6.3
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+arrow==1.2.3
+astunparse==1.6.3
+async-timeout==4.0.2
+attrs==22.2.0
+Babel==2.12.1
+beautifulsoup4==4.12.1
+bleach==6.0.0
+blinker==1.6
+cachetools==4.2.2
+certifi==2022.12.7
+cffi==1.15.1
+charset-normalizer==3.1.0
+click==8.1.3
+colorama==0.4.6
+contourpy==1.0.7
+cycler==0.11.0
+dataclasses-json==0.5.7
+datasets==2.11.0
+defusedxml==0.7.1
+dill==0.3.6
+e==1.4.5
+evaluate==0.4.0
+fastapi==0.103.0
+fastjsonschema==2.16.3
+ffmpy==0.3.1
+filelock==3.10.7
+flatbuffers==23.3.3
+fonttools==4.39.3
+fqdn==1.5.1
+frozenlist==1.3.3
+fsspec==2023.3.0
+ftfy==6.1.1
+gast==0.4.0
+gdown==4.7.1
+gitdb==4.0.10
+GitPython==3.1.31
+google-auth==2.17.0
+google-auth-oauthlib==1.0.0
+google-pasta==0.2.0
+gradio==3.41.2
+gradio_client==0.5.0
+grpcio==1.53.0
+h11==0.14.0
+h5py
+httpcore==0.17.3
+httpx==0.24.1
+huggingface-hub==0.16.4
+idna==3.4
+imageio==2.31.0
+imgaug==0.4.0
+importlib-metadata==6.1.0
+importlib-resources==5.12.0
+ipykernel
+ipython
+ipython-genutils==0.2.0
+isoduration==20.11.0
+jax==0.4.8
+jedi
+Jinja2==3.1.2
+joblib==1.2.0
+json-fix==0.5.2
+json5==0.9.11
+jsonpointer==2.3
+jsonschema==4.17.3
+jupyter-events==0.6.3
+jupyter-http-over-ws==0.0.8
+jupyter-server==1.23.6
+jupyter-ydoc==0.2.3
+jupyter_client==7.4.1
+jupyter_core
+jupyter_server_fileid==0.8.0
+jupyter_server_terminals==0.4.4
+jupyter_server_ydoc==0.8.0
+jupyterlab==3.6.3
+jupyterlab-pygments==0.2.2
+jupyterlab_server==2.22.0
+keras==2.13.1
+kiwisolver==1.4.4
+langchain==0.0.158
+lazy_loader==0.2
+libclang==16.0.0
+lightning-utilities==0.8.0
+Markdown==3.4.3
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+marshmallow==3.19.0
+marshmallow-enum==1.5.1
+matplotlib==3.7.1
+matplotlib-inline
+mdurl==0.1.2
+mistune==2.0.5
+ml-dtypes==0.0.4
+mpmath==1.3.0
+multidict==6.0.4
+multiprocess==0.70.14
+mypy-extensions==1.0.0
+nbclassic==0.5.5
+nbclient==0.7.3
+nbconvert==7.3.0
+nbformat==5.8.0
+nest-asyncio
+networkx==3.0
+notebook==6.5.3
+notebook_shim==0.2.2
+numexpr==2.8.4
+numpy==1.23.5
+oauthlib==3.2.2
+omegaconf==2.3.0
+openai==0.27.4
+openapi-schema-pydantic==1.2.4
+opencv-python==4.7.0.72
+opt-einsum==3.3.0
+orjson==3.9.5
+packaging
+pandas==1.5.3
+pandocfilters==1.5.0
+parso
+pexpect
+pickleshare
+Pillow==9.4.0
+platformdirs
+plotly==5.14.0
+powerlaw==1.5
+prometheus-client==0.16.0
+prompt-toolkit
+protobuf==3.20.3
+psutil
+ptyprocess
+pure-eval
+pyarrow==11.0.0
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pycparser==2.21
+pydantic==1.10.7
+pydeck==0.8.0
+pydub==0.25.1
+Pygments
+Pympler==1.0.1
+pyparsing==3.0.9
+pyrsistent==0.19.3
+PySocks==1.7.1
+python-dateutil
+python-json-logger==2.0.7
+python-multipart==0.0.6
+python-telegram-bot==13.7
+pytorch-lightning==2.0.1.post0
+pytz==2023.3
+pytz-deprecation-shim==0.1.0.post0
+PyWavelets==1.4.1
+PyYAML==6.0
+pyzmq==25.0.2
+regex==2023.3.23
+requests==2.28.2
+requests-oauthlib==1.3.1
+responses==0.18.0
+retina-face==0.0.13
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rich==13.3.3
+river==0.14.0
+rsa==4.9
+scikit-image==0.21.0
+scikit-learn==1.2.2
+scipy==1.10.1
+semantic-version==2.10.0
+semver==3.0.0
+Send2Trash==1.8.0
+shapely==2.0.1
+smmap==5.0.0
+sniffio==1.3.0
+soupsieve==2.4
+SQLAlchemy==2.0.12
+starlette==0.27.0
+streamlit==1.20.0
+sympy==1.11.1
+tabulate==0.9.0
+tenacity==8.2.2
+tensorboard==2.13.0
+tensorboard-data-server==0.7.0
+tensorboard-plugin-wit==1.8.1
+tensorflow==2.13.0
+tensorflow-estimator==2.13.0
+termcolor==2.2.0
+terminado==0.17.1
+threadpoolctl==3.1.0
+tifffile==2023.4.12
+tinycss2==1.2.1
+tokenizers==0.13.2
+toml==0.10.2
+tomli==2.0.1
+toolz==0.12.0
+torch==2.0.0
+torchaudio==2.0.1
+torchmetrics==0.11.4
+torchvision==0.15.1
+tornado==6.2
+tqdm==4.65.0
+transformers==4.27.4
+typing-inspect==0.8.0
+tzdata==2023.3
+tzlocal==4.3
+uri-template==1.2.0
+urllib3==1.26.15
+uvicorn==0.23.2
+validators==0.20.0
+voila==0.4.0
+webcolors==1.13
+webencodings==0.5.1
+websocket-client==1.5.1
+websockets==11.0.1
+weightwatcher==0.7.0.8
+Werkzeug==2.2.3
+wikipedia==1.4.0
+wrapt==1.14.1
+xxhash==3.2.0
+y-py==0.5.9
+yarl==1.8.2
+ypy-websocket==0.8.2
+zipp==3.15.0

train.py

@@ -0,0 +1,183 @@
+import numpy as np
+import os
+import sys
+import cv2
+import torch
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+import torchvision
+from torchvision import transforms
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data.sampler import SubsetRandomSampler
+
+
+sys.path.append('/Users/suyashharlalka/Documents/workspace/gabit/acne_classification/code')
+
+from dataset import AcneDataset
+from utils import save_model, get_transforms_to_apply,get_model_architecture, get_training_params, get_criterion
+import config
+from base import TrainingObjective, ModelBackbone
+import json
+
+
+
+data_dir = config.DATASET_PATH
+image_names = os.listdir(data_dir)
+model_training = config.MODEL_TRAINING
+isLimited = config.IS_LIMITED
+batch_size = config.BATCH_SIZE
+shuffle = config.SHUFFLE
+num_workers = config.NUM_WORKERS
+
+dataset = AcneDataset(data_dir, limit=isLimited)
+
+validation_split = 0.2
+dataset_size = len(dataset)
+indices = list(range(dataset_size))
+split = int(np.floor(validation_split * dataset_size))
+if shuffle:
+    np.random.seed(42)
+    np.random.shuffle(indices)
+
+train_indices, test_indices = indices[split:], indices[:split]
+train_sampler = SubsetRandomSampler(train_indices)
+test_sampler = SubsetRandomSampler(test_indices)
+
+transform = get_transforms_to_apply()
+dataset.transform = transform
+
+train_dataloader = DataLoader(dataset, batch_size=batch_size, num_workers=num_workers, sampler=train_sampler)
+test_dataloader = DataLoader(dataset, batch_size=batch_size, num_workers=num_workers, sampler=test_sampler)
+
+num_classes = config.NUM_CLASSES
+model = get_model_architecture()
+training_params = get_training_params(model)
+criterion = get_criterion()
+
+optimizer = optim.Adam(training_params, lr=config.BASE_LR)
+scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=config.LR_DECAY_STEP_SIZE, gamma=config.LR_DECAY_GAMMA)
+
+device = torch.device('mps') if torch.backends.mps.is_available() else torch.device('cpu')
+model.to(device)
+
+config_json = {}
+config_json['DATASET_PATH'] = config.DATASET_PATH
+config_json['MODEL_DIR'] = config.MODEL_DIR
+config_json['MODEL_OBJECTIVE'] = config.MODEL_OBJECTIVE.name
+config_json['MODEL_BACKBONE'] = config.MODEL_BACKBONE.name
+config_json['MODEL_INPUT_SIZE'] = config.MODEL_INPUT_SIZE
+config_json['TRANSFORMS_TO_APPLY'] = config.TRANSFORMS_TO_APPLY
+config_json['NUM_CLASSES'] = config.NUM_CLASSES
+config_json['LAST_N_LAYERS_TO_TRAIN'] = config.LAST_N_LAYERS_TO_TRAIN
+config_json['EPOCHS'] = config.EPOCHS
+config_json['MODEL_TRAINING'] = config.MODEL_TRAINING
+config_json['IS_LIMITED'] = config.IS_LIMITED
+config_json['BATCH_SIZE'] = config.BATCH_SIZE
+config_json['SHUFFLE'] = config.SHUFFLE
+config_json['NUM_WORKERS'] = config.NUM_WORKERS
+config_json['BASE_LR'] = config.BASE_LR
+config_json['LR_DECAY_STEP_SIZE'] = config.LR_DECAY_STEP_SIZE
+config_json['LR_DECAY_GAMMA'] = config.LR_DECAY_GAMMA
+
+
+if model_training:
+    num_epochs = config.EPOCHS
+    for epoch in range(num_epochs):
+        model.train()
+        runningLoss = 0.0
+        for i, (images, labels) in enumerate(tqdm(train_dataloader, desc="Processing", unit="batch")):
+            images = images.to(device)
+            labels = labels.to(device)
+            outputs = model(images)
+            loss = criterion(outputs.squeeze(), labels)
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            runningLoss += loss.item()
+        
+        # scheduler.step()
+        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {runningLoss/len(train_dataloader):.4f}')
+        
+        if 'LOSS' not in config_json:
+            config_json['LOSS'] = []
+        config_json['LOSS'].append(runningLoss/len(train_dataloader))
+
+        if 'EPOCHS_DONE' not in config_json:
+            config_json['EPOCHS_DONE'] = 0
+        config_json['EPOCHS_DONE'] = epoch + 1
+
+        if epoch == 0 :
+            model_dir = save_model(model, config_json)
+        else:
+            model_dir = save_model(model, config_json, model_dir)
+        
+        if 'TRAINED_MODEL_DIR' not in config_json:
+            config_json['TRAINED_MODEL_DIR'] = model_dir
+        
+        config_save_path = os.path.join(model_dir, 'config.json')
+        with open(config_save_path, 'w') as f:
+            json.dump(config_json, f)
+
+
+# config_path = os.path.join(model_dir, 'config.json')   
+config_path = '/Users/suyash.harlalka/Desktop/personal/acne_classification/model/model_1/config.json' 
+with open(config_path, 'r') as f:
+    config_loaded = json.load(f)
+
+from sklearn.metrics import confusion_matrix
+
+model_trained_path = os.path.join(config_loaded['TRAINED_MODEL_DIR'], 'model.pth')
+model.load_state_dict(torch.load(model_trained_path))
+model.eval()
+with torch.no_grad():
+    correct = 0
+    total = 0
+    mainLabel = []
+    predictedLabel = []
+    for images, labels in tqdm(test_dataloader, desc="Processing", unit="batch"):
+        images = images.to(device)
+        labels = labels.to(device)
+        outputs = model(images)
+        predicted = torch.round(outputs.data)
+        predicted = predicted.squeeze(1)
+        total += labels.size(0)
+        correct += (predicted == labels).sum().item()
+
+        mainLabel.extend(labels.cpu().numpy())
+        predictedLabel.extend(predicted.cpu().numpy())
+        
+    print(f'Accuracy of the network on the {total} test images: {100 * correct / total}%')
+    
+    cft = confusion_matrix(mainLabel, predictedLabel, labels=[0, 1, 2, 3], normalize='true')
+    print(cft)
+
+    correct = 0
+    total = 0
+    mainLabel = []
+    predictedLabel = []
+    for images, labels in tqdm(train_dataloader, desc="Processing", unit="batch"):
+        images = images.to(device)
+        labels = labels.to(device)
+        outputs = model(images)
+        predicted = torch.round(outputs.data)
+        predicted = predicted.squeeze(1)
+        total += labels.size(0)
+        correct += (predicted == labels).sum().item()
+
+        mainLabel.extend(labels.cpu().numpy())
+        predictedLabel.extend(predicted.cpu().numpy())
+    
+    print(f'Accuracy of the network on the {total} train images: {100 * correct / total}%')
+    cft = confusion_matrix(mainLabel, predictedLabel, labels=[0, 1, 2, 3], normalize='true')
+    print(cft)
+
+
+
+
+
+
+
+
+        
+        

utils.py

@@ -0,0 +1,111 @@
+
+from config import MODEL_DIR, MODEL_INPUT_SIZE, TRANSFORMS_TO_APPLY, MODEL_BACKBONE, MODEL_OBJECTIVE, LAST_N_LAYERS_TO_TRAIN
+import os
+import torch
+import json
+from base import TransformationType, ModelBackbone, TrainingObjective
+from torchvision import transforms
+import torchvision
+import torch.nn as nn
+
+
+
+def save_model(model, config_json,model_dir = None):
+    if model_dir is None:
+        model_basedir = MODEL_DIR
+        models_present_in_dir = os.listdir(model_basedir)
+
+        model_dir_name = 'model_{}'.format(len(models_present_in_dir))
+        model_dir = os.path.join(model_basedir, model_dir_name)
+        os.mkdir(model_dir)
+
+    model_path = os.path.join(model_dir, 'model.pth')
+    torch.save(model.state_dict(), model_path)
+    config_path = os.path.join(model_dir, 'config.json')
+    # import pdb; pdb.set_trace()
+    with open(config_path, 'w') as f:
+        json.dump(config_json, f)
+    
+    return model_dir
+
+def get_transforms_to_apply_(transformation_type, config_json = None):
+    if config_json:
+        model_input_size = config_json['MODEL_INPUT_SIZE']
+    else:
+        model_input_size = MODEL_INPUT_SIZE
+
+    if transformation_type == TransformationType.RESIZE:
+        return transforms.Resize(model_input_size)
+    elif transformation_type == TransformationType.TO_TENSOR:
+        return transforms.ToTensor()
+    elif transformation_type == TransformationType.RANDOM_HORIZONTAL_FLIP:
+        return transforms.RandomHorizontalFlip(p=0.5)
+    elif transformation_type == TransformationType.NORMALIZE:
+        return transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                                    std=[0.229, 0.224, 0.225])
+    elif transformation_type == TransformationType.RANDOM_ROTATION:
+        return transforms.RandomRotation(degrees=10)
+    elif transformation_type == TransformationType.RANDOM_CLIP:
+        return transforms.RandomCrop(model_input_size)
+    else:
+        raise Exception("Invalid transformation type")
+
+def get_transforms_to_apply():
+    transforms_to_apply = []
+    for transform in TRANSFORMS_TO_APPLY:
+        transforms_to_apply.append(get_transforms_to_apply_(TransformationType[transform]))
+    return transforms.Compose(transforms_to_apply)
+
+def get_model_architecture(config_json = None):
+    if config_json:
+        model_backbone = ModelBackbone[config_json['MODEL_BACKBONE']]
+        model_objective = TrainingObjective[config_json['MODEL_OBJECTIVE']]
+    else:
+        model_backbone = MODEL_BACKBONE
+        model_objective = MODEL_OBJECTIVE
+    if model_backbone == ModelBackbone.EFFICIENT_NET_B0:
+        if model_objective == TrainingObjective.REGRESSION:
+            model = torchvision.models.efficientnet_b0(pretrained=True)
+            model.classifier[1] = nn.Sequential(
+                nn.Linear(model.classifier[1].in_features, 2048),
+                nn.ReLU(),
+                nn.Dropout(0.5),
+                nn.Linear(2048, 1),
+            )
+        else:
+            raise Exception("Invalid model objective")
+    else:
+        raise Exception("Invalid model backbone")
+    
+    return model
+
+def get_training_params(model):
+    training_params = []
+    if MODEL_BACKBONE == ModelBackbone.EFFICIENT_NET_B0:
+        if LAST_N_LAYERS_TO_TRAIN > 0:
+            for param in model.features[:-LAST_N_LAYERS_TO_TRAIN].parameters():
+                param.requires_grad = False
+            
+            for param in model.features[-LAST_N_LAYERS_TO_TRAIN:].parameters():
+                training_params.append(param)
+
+
+        for param in model.classifier[1].parameters():
+            training_params.append(param)
+    else:
+        raise Exception("Invalid model backbone")
+
+    return training_params
+
+def get_criterion():
+    if MODEL_OBJECTIVE == TrainingObjective.REGRESSION:
+        criterion = nn.MSELoss()
+    else:
+        raise Exception("Invalid model objective")
+    
+    return criterion    
+      
+
+
+
+