Init gradio repo

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,153 @@
+# 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
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__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/

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.10-slim
+
+WORKDIR /workspace
+ADD requirements.txt /workspace/requirements.txt
+RUN pip install -U pip
+RUN pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+RUN pip install -r /workspace/requirements.txt
+
+COPY src /workspace/src
+
+ENV HOME=/workspace
+CMD ["python", "src/app.py", "--host", "0.0.0.0", "--port", "7860"]
+# ENTRYPOINT python src/app.py

requirements.txt

@@ -0,0 +1,9 @@
+--find-links https://download.pytorch.org/whl/torch_stable.html
+torch==2.0.1+cpu
+--find-links https://download.pytorch.org/whl/torch_stable.html
+torchvision==0.15.2+cpu
+efficientnet-pytorch==0.7.1
+gradio==3.44.4
+Markdown==3.4.4
+Pillow==10.0.1
+tqdm==4.66.1

src/CustomModels.py

@@ -0,0 +1,18 @@
+import torch
+
+class DinoVisionClassifier(torch.nn.Module):
+    def __init__(self, dinov2, num_classes=5):
+        super(DinoVisionClassifier, self).__init__()
+        self.transformer = dinov2
+        self.classifier = torch.nn.Sequential(
+            torch.nn.Linear(384, 64),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.2),
+            torch.nn.Linear(64, num_classes)
+        )
+    
+    def forward(self, x):
+        x = self.transformer(x)
+        x = self.transformer.norm(x)
+        x = self.classifier(x)
+        return x

src/app.py

@@ -0,0 +1,82 @@
+import gradio as gr
+from utils import load_specific_model, inference
+import markdown
+
+current_model = None  # Initialize the current model as None
+
+# Define a set of example images
+example_images = [
+    ("Beispielbild Glas", "src/examples/Glas.jpg"),
+    ("Beispielbild Organic", "src/examples/Organic.jpg"),
+    ("Beispielbild Papier", "src/examples/Papier.jpg"),
+    ("Beispielbild Restmüll", "src/examples/Restmuell.jpg"),
+    ("Beispielbild Wertstoff", "src/examples/Wertstoff.jpg")
+]
+
+def load_model(model_name):
+    global current_model
+    if model_name is None:
+        raise gr.Error("No model selected!")
+    if current_model is not None:
+        current_model = None
+
+    current_model = load_specific_model(model_name)
+    current_model.eval()
+
+def predict(inp):
+    global current_model
+    if current_model is None:
+        raise gr.Error("No model loaded!")
+
+    confidences = inference(current_model, inp)
+    return confidences
+
+with gr.Blocks() as demo:
+    with open('src/app_template.md', 'r') as f:
+        markdown_string = f.read()
+    header = gr.Markdown(markdown_string)
+    
+    with gr.Row(variant="panel", equal_height=True):
+
+        user_image = gr.Image(
+            type="pil",
+            label="Upload Your Own Image",
+            info="You can also upload your own image for prediction.",
+            scale=2,
+            height=350,
+        )
+        
+        with gr.Column():
+            output = gr.Label(
+                num_top_classes=3,
+                label="Output",
+                info="Top three predicted classes and their confidences.",
+                scale=2,
+            )
+
+            model_dropdown = gr.Dropdown(
+                ["EfficientNet-B3", "EfficientNet-B4", "vgg19", "resnet50", "dinov2_vits14"],
+                label="Model",
+                info="Select a model to use.",
+                scale=1,
+            )
+            model_dropdown.change(load_model, model_dropdown, show_progress=True, queue=True)
+            predict_button = gr.Button(label="Predict", info="Click to make a prediction.", scale=1)
+            predict_button.click(fn=predict, inputs=user_image, outputs=output, queue=True)
+
+    gr.Markdown("## Example Images")
+    gr.Markdown("You can just drag and drop these images into the image uploader above!")
+    
+    with gr.Row():
+        for name, image_path in example_images:
+            example_image = gr.Image(
+                value=image_path,
+                label=name,
+                type="pil",
+                height=220,
+                interactive=False,
+            )
+
+if __name__ == "__main__":
+    demo.queue()
+    demo.launch()

src/app_template.md

@@ -0,0 +1,6 @@
+# Waste Classification Demo
+This interactive demo allows you to classify waste items using various deep learning models. Choose a model, upload an image of a waste item, and click the "Predict" button to view the top three predicted classes and their confidences. The project was developed by [Ilyesse Hettenbach](https://github.com/ilyii) and [Gabriel Schurr](https://github.com/Gabriel9753) as part of a project work at the [University of Applied Sciences Karlsruhe](https://www.h-ka.de/).  
+Enjoy using the Waste Classification Demo to classify waste items and explore the capabilities of different deep learning models!
+
+## Models
+The demo currently supports the following models: [EfficientNet-B3](https://arxiv.org/abs/1905.11946), [EfficientNet-B4](https://arxiv.org/abs/1905.11946), [VGG19](https://arxiv.org/abs/1409.1556), [ResNet50](https://arxiv.org/abs/1512.03385), and [DinoV2](https://arxiv.org/abs/2304.07193) in its smallest variant. The models were primarily trained on data we generated.

src/download_models.py

@@ -0,0 +1,41 @@
+'''
+This file is just used to download the models from the internet. 
+'''
+from torchvision import models
+from efficientnet_pytorch import EfficientNet
+import torch
+
+def main():
+    try:
+        print("Downloading EfficientNet-B3...")
+        _ = EfficientNet.from_pretrained("efficientnet-b3")
+    except Exception as e:
+        print(f"Error while downloading EfficientNet-B3: {e}")
+        
+    try:
+        print("Downloading EfficientNet-B4...")
+        _ = EfficientNet.from_pretrained("efficientnet-b4")
+    except Exception as e:
+        print(f"Error while downloading EfficientNet-B4: {e}")
+        
+    try:
+        print("Downloading vgg19...")
+        _ = models.vgg19()
+    except Exception as e:
+        print(f"Error while downloading vgg19: {e}")
+        
+    try:
+        print("Downloading resnet50...")
+        _ = models.resnet50()
+    except Exception as e:
+        print(f"Error while downloading resnet50: {e}")
+    
+    try:
+        print("Downloading dinov2_vits14...")
+        _ = torch.hub.load('facebookresearch/dinov2', "dinov2_vits14")
+    except Exception as e:
+        print(f"Error while downloading dinov2_vits14: {e}")
+    
+    
+if __name__ == "__main__":
+    main()

src/models/dinov2_info.txt

@@ -0,0 +1,31 @@
+Model: dinov2_vits14
+Timestamp: 2023-09-25_17-27-57
+Batch Size: 128
+Learning Rate: 2e-06
+Number of Epochs: 20
+Linear Layer: [384, 64, 5]
+Dropout: 0.2
+Train length: 18108
+Validation length: 4656
+
+Train History:
+Epoch 1: Acc 91.000 | Loss 0.283
+Epoch 2: Acc 94.000 | Loss 0.174
+Epoch 3: Acc 95.000 | Loss 0.137
+Epoch 4: Acc 96.000 | Loss 0.115
+Epoch 5: Acc 96.000 | Loss 0.095
+Epoch 6: Acc 96.000 | Loss 0.088
+Epoch 7: Acc 97.000 | Loss 0.087
+Epoch 8: Acc 97.000 | Loss 0.080
+Epoch 9: Acc 97.000 | Loss 0.077
+Epoch 10: Acc 97.000 | Loss 0.076
+Epoch 11: Acc 97.000 | Loss 0.075
+Epoch 12: Acc 97.000 | Loss 0.069
+Epoch 13: Acc 97.000 | Loss 0.081
+Epoch 14: Acc 97.000 | Loss 0.068
+Epoch 15: Acc 98.000 | Loss 0.059
+Epoch 16: Acc 97.000 | Loss 0.063
+Epoch 17: Acc 98.000 | Loss 0.054
+Epoch 18: Acc 97.000 | Loss 0.058
+Epoch 19: Acc 97.000 | Loss 0.067
+Epoch 20: Acc 98.000 | Loss 0.060

src/models/dinov2_vits14_0.054_98.00.pth

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

src/models/eff_b3_model.pt

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

src/models/eff_b4.pt

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

src/models/resnet50.pt

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

src/models/vgg19.pt

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

src/utils.py

@@ -0,0 +1,65 @@
+from torchvision import transforms
+from torchvision import models
+from efficientnet_pytorch import EfficientNet
+import torch
+from CustomModels import DinoVisionClassifier
+
+classes = {0: 'Glas', 1: 'Organic', 2: 'Papier', 3: 'Restmüll', 4: 'Wertstoff'}
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+transform = transforms.Compose(
+    [transforms.Resize((256, 256), interpolation=transforms.InterpolationMode.BICUBIC),
+     transforms.ToTensor(),
+     transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
+     ]
+)
+
+transform_dinov2 = transforms.Compose(
+    [   transforms.Resize(256),
+        transforms.CenterCrop(224),
+        transforms.ToTensor(),
+        transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
+     ]
+)
+
+def load_specific_model(model_name):
+    current_model = None
+    if model_name == "EfficientNet-B3":
+        current_model = EfficientNet.from_pretrained("efficientnet-b3", num_classes=len(classes.keys()))
+        current_model.load_state_dict(torch.load("src/models/eff_b3_model.pt", map_location="cpu"))
+    elif model_name == "EfficientNet-B4":
+        current_model = EfficientNet.from_pretrained("efficientnet-b4", num_classes=len(classes.keys()))
+        current_model.load_state_dict(torch.load("src/models/eff_b4.pt", map_location="cpu"))
+    elif model_name == "vgg19":
+        current_model = models.vgg19()
+        in_features = current_model.classifier[0].in_features
+        current_model.classifier = torch.nn.Linear(in_features, len(classes.keys()))
+        current_model.load_state_dict(torch.load("src/models/vgg19.pt", map_location="cpu"))
+    elif model_name == "resnet50":
+        current_model = models.resnet50()
+        in_features = current_model.fc.in_features
+        current_model.fc = torch.nn.Linear(in_features, len(classes.keys()))
+        current_model.load_state_dict(torch.load("src/models/resnet50.pt", map_location="cpu"))
+    elif model_name == "dinov2_vits14":
+        current_model = torch.hub.load('facebookresearch/dinov2', "dinov2_vits14")
+        current_model = DinoVisionClassifier(current_model, num_classes=len(classes.keys()))
+        current_model.load_state_dict(torch.load("src/models/dinov2_vits14_0.054_98.00.pth", map_location="cpu"))
+    
+    print(f"Loaded model {model_name}")
+    return current_model.eval().to(device)
+    
+def inference(model, inp):
+    model.eval()
+    inp = transform(inp) if model.__class__.__name__ != "DinoVisionClassifier" else transform_dinov2(inp)
+    inp = inp.unsqueeze(0).to(device)
+    if torch.cuda.is_available():
+        with torch.no_grad(), torch.cuda.amp.autocast():
+            prediction = torch.nn.functional.softmax(model(inp)[0], dim=0).cpu().numpy()
+    else:
+        with torch.no_grad():
+            prediction = torch.nn.functional.softmax(model(inp)[0], dim=0).cpu().numpy()
+        
+    confidences = {classes[i]: float(prediction[i]) for i in range(len(classes.keys()))}
+    return confidences
+