first commit

.gitignore

@@ -0,0 +1,148 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Local folder
+local_folder
+project_demo
+project_demo/
+logs/
+local_folder/
+/demo.py
+demo.py
+runs/
+
+# Large folders
+weights/
+videos/
+images/
+
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+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
+
+.vscode
+
+# 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/
+
+# 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
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.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
+
+# 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/
+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/

app.py

@@ -0,0 +1,193 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import transforms, models
+from PIL import Image, UnidentifiedImageError
+import streamlit as st
+import numpy as np
+import requests
+from io import BytesIO
+from kan_linear import KANLinear
+import logging
+import os
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+
+# Define the model
+class KANVGG16(nn.Module):
+    def __init__(self, num_classes=1):  # For binary classification (cats and dogs)
+        super(KANVGG16, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.BatchNorm2d(64),  # Added Batch Normalization
+
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.BatchNorm2d(128),  # Added Batch Normalization
+
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.BatchNorm2d(256),  # Added Batch Normalization
+
+            nn.Conv2d(256, 512, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.BatchNorm2d(512),  # Added Batch Normalization
+
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.BatchNorm2d(512),  # Added Batch Normalization
+        )
+        self.classifier = nn.Sequential(
+            KANLinear(512 * 7 * 7, 2048),  # Adjusted for input size 224x224
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),  # Increased Dropout
+            KANLinear(2048, 2048),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),  # Increased Dropout
+            KANLinear(2048, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x
+
+def load_model(weights_path, device):
+    model = KANVGG16().to(device)
+    state_dict = torch.load(weights_path, map_location=device)
+    
+    # Remove 'module.' prefix from keys
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        if k.startswith('module.'):
+            new_state_dict[k[len('module.'):]] = v
+        else:
+            new_state_dict[k] = v
+
+    model.load_state_dict(new_state_dict)
+    model.eval()
+    return model
+
+class CustomImageLoadingError(Exception):
+    """Custom exception for image loading errors"""
+    pass
+
+def load_image_from_url(url):
+    try:
+        logging.info(f"Loading image from URL: {url}")
+
+        # Check the file extension
+        valid_extensions = ['jpg', 'jpeg', 'png', 'webp']
+        file_extension = os.path.splitext(url)[1][1:].lower()
+        if file_extension not in valid_extensions:
+            raise CustomImageLoadingError(f"URL does not point to an image with a valid extension: {file_extension}")
+
+        response = requests.get(url)
+        response.raise_for_status()  # Check if the request was successful
+
+        content_type = response.headers['Content-Type']
+        logging.info(f"Content-Type: {content_type}")
+
+        # Check if the content type is an image
+        if 'image' not in content_type:
+            raise CustomImageLoadingError(f"URL does not point to an image: {content_type}")
+
+        img = Image.open(BytesIO(response.content)).convert('RGB')
+        logging.info("Image successfully loaded and converted to RGB")
+        return img
+    except requests.HTTPError as e:
+        logging.error(f"HTTPError while loading image: {e}")
+        raise CustomImageLoadingError(f"Error loading image from URL: {e}")
+    except UnidentifiedImageError as e:
+        logging.error(f"UnidentifiedImageError while loading image: {e}")
+        raise CustomImageLoadingError(f"Cannot identify image file: {e}")
+    except requests.RequestException as e:
+        logging.error(f"RequestException while loading image: {e}")
+        raise CustomImageLoadingError(f"Error loading image from URL: {e}")
+    except Exception as e:
+        logging.error(f"Unexpected error while loading image: {e}")
+        raise CustomImageLoadingError(f"Error loading image from URL: {e}")
+
+def preprocess_image(image):
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor()
+    ])
+    return transform(image).unsqueeze(0)
+
+# Streamlit app
+st.title("Cat and Dog Classification with VGG16-KAN")
+
+st.sidebar.title("Upload Images")
+uploaded_file = st.sidebar.file_uploader("Choose an image...", type=["jpg", "jpeg", "png", "webp"])
+image_url = st.sidebar.text_input("Or enter image URL...")
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = load_model('weights/best_model_vgg16_KAN.pth', device)
+
+img = None
+
+if uploaded_file is not None:
+    logging.info("Image uploaded via file uploader")
+    img = Image.open(uploaded_file).convert('RGB')
+elif image_url:
+    try:
+        img = load_image_from_url(image_url)
+    except CustomImageLoadingError as e:
+        st.sidebar.error(str(e))
+    except Exception as e:
+        st.sidebar.error(f"Unexpected error: {e}")
+
+st.sidebar.write("-----")
+
+# Define your information for the footer
+name = "Wayan Dadang"
+
+st.sidebar.write("Follow me on:")
+# Create a footer section with links and copyright information
+st.sidebar.markdown(f"""
+    [LinkedIn](https://www.linkedin.com/in/wayan-dadang-801757116/)
+    [GitHub](https://github.com/Wayan123)
+    [Resume](https://wayan123.github.io/)
+    © {name} - {2024}
+    """, unsafe_allow_html=True)
+
+if img is not None:
+    st.image(np.array(img), caption='Uploaded Image.', use_column_width=True)
+    if st.button('Predict'):
+        img_tensor = preprocess_image(img).to(device)
+
+        with torch.no_grad():
+            output = model(img_tensor)
+            prob = torch.sigmoid(output).item()
+
+        st.write(f"Prediction: {prob:.4f}")
+
+        if prob < 0.5:
+            st.write("This image is classified as a Cat.")
+        else:
+            st.write("This image is classified as a Dog.")

kan_linear.py

@@ -0,0 +1,91 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+class KANLinear(nn.Module):
+    def __init__(self, in_features, out_features, grid_size=5, spline_order=3, scale_noise=0.1, scale_base=1.0, scale_spline=1.0, enable_standalone_scale_spline=True, base_activation=nn.SiLU, grid_eps=0.02, grid_range=[-1, 1]):
+        super(KANLinear, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.grid_size = grid_size
+        self.spline_order = spline_order
+
+        h = (grid_range[1] - grid_range[0]) / grid_size
+        grid = ((torch.arange(-spline_order, grid_size + spline_order + 1) * h + grid_range[0]).expand(in_features, -1).contiguous())
+        self.register_buffer("grid", grid)
+
+        self.base_weight = nn.Parameter(torch.Tensor(out_features, in_features))
+        self.spline_weight = nn.Parameter(torch.Tensor(out_features, in_features, grid_size + spline_order))
+        if enable_standalone_scale_spline:
+            self.spline_scaler = nn.Parameter(torch.Tensor(out_features, in_features))
+
+        self.scale_noise = scale_noise
+        self.scale_base = scale_base
+        self.scale_spline = scale_spline
+        self.enable_standalone_scale_spline = enable_standalone_scale_spline
+        self.base_activation = base_activation()
+        self.grid_eps = grid_eps
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.kaiming_uniform_(self.base_weight, a=math.sqrt(5) * self.scale_base)
+        with torch.no_grad():
+            noise = ((torch.rand(self.grid_size + 1, self.in_features, self.out_features) - 1 / 2) * self.scale_noise / self.grid_size)
+            self.spline_weight.data.copy_((self.scale_spline if not self.enable_standalone_scale_spline else 1.0) * self.curve2coeff(self.grid.T[self.spline_order : -self.spline_order], noise))
+            if self.enable_standalone_scale_spline:
+                nn.init.kaiming_uniform_(self.spline_scaler, a=math.sqrt(5) * self.scale_spline)
+
+    def b_splines(self, x: torch.Tensor):
+        assert x.dim() == 2 and x.size(1) == self.in_features
+        grid = self.grid
+        x = x.unsqueeze(-1)
+        bases = ((x >= grid[:, :-1]) & (x < grid[:, 1:])).to(x.dtype)
+        for k in range(1, self.spline_order + 1):
+            bases = ((x - grid[:, : -(k + 1)]) / (grid[:, k:-1] - grid[:, : -(k + 1)]) * bases[:, :, :-1]) + ((grid[:, k + 1 :] - x) / (grid[:, k + 1 :] - grid[:, 1:(-k)]) * bases[:, :, 1:])
+        assert bases.size() == (x.size(0), self.in_features, self.grid_size + self.spline_order)
+        return bases.contiguous()
+
+    def curve2coeff(self, x: torch.Tensor, y: torch.Tensor):
+        assert x.dim() == 2 and x.size(1) == self.in_features
+        assert y.size() == (x.size(0), self.in_features, self.out_features)
+        A = self.b_splines(x).transpose(0, 1)
+        B = y.transpose(0, 1)
+        solution = torch.linalg.lstsq(A, B).solution
+        result = solution.permute(2, 0, 1)
+        assert result.size() == (self.out_features, self.in_features, self.grid_size + self.spline_order)
+        return result.contiguous()
+
+    @property
+    def scaled_spline_weight(self):
+        return self.spline_weight * (self.spline_scaler.unsqueeze(-1) if self.enable_standalone_scale_spline else 1.0)
+
+    def forward(self, x: torch.Tensor):
+        assert x.dim() == 2 and x.size(1) == self.in_features
+        base_output = F.linear(self.base_activation(x), self.base_weight)
+        spline_output = F.linear(self.b_splines(x).view(x.size(0), -1), self.scaled_spline_weight.view(self.out_features, -1))
+        return base_output + spline_output
+
+    @torch.no_grad()
+    def update_grid(self, x: torch.Tensor, margin=0.01):
+        assert x.dim() == 2 and x.size(1) == self.in_features
+        batch = x.size(0)
+        splines = self.b_splines(x).permute(1, 0, 2)
+        orig_coeff = self.scaled_spline_weight.permute(1, 2, 0)
+        unreduced_spline_output = torch.bmm(splines, orig_coeff).permute(1, 0, 2)
+        x_sorted = torch.sort(x, dim=0)[0]
+        grid_adaptive = x_sorted[torch.linspace(0, batch - 1, self.grid_size + 1, dtype=torch.int64, device=x.device)]
+        uniform_step = (x_sorted[-1] - x_sorted[0] + 2 * margin) / self.grid_size
+        grid_uniform = (torch.arange(self.grid_size + 1, dtype=torch.float32, device=x.device).unsqueeze(1) * uniform_step + x_sorted[0] - margin)
+        grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive
+        grid = torch.cat([grid[:1] - uniform_step * torch.arange(self.spline_order, 0, -1, device=x.device).unsqueeze(1), grid, grid[-1:] + uniform_step * torch.arange(1, self.spline_order + 1, device=x.device).unsqueeze(1)], dim=0)
+        self.grid.copy_(grid.T)
+        self.spline_weight.data.copy_(self.curve2coeff(x, unreduced_spline_output))
+
+    def regularization_loss(self, regularize_activation=1.0, regularize_entropy=1.0):
+        l1_fake = self.spline_weight.abs().mean(-1)
+        regularization_loss_activation = l1_fake.sum()
+        p = l1_fake / regularization_loss_activation
+        regularization_loss_entropy = -torch.sum(p * p.log())
+        return regularize_activation * regularization_loss_activation + regularize_entropy * regularization_loss_entropy

requirements.txt

@@ -0,0 +1,79 @@
+altair==5.2.0
+attrs==23.2.0
+blinker==1.7.0
+cachetools==5.3.3
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.2.0
+cycler==0.12.1
+filelock==3.13.1
+fonttools==4.50.0
+fsspec==2024.3.1
+gitdb==4.0.11
+GitPython==3.1.42
+idna==3.6
+Jinja2==3.1.3
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.5
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.8.3
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.2.1
+numpy==1.26.4
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.19.3
+nvidia-nvjitlink-cu12==12.4.99
+nvidia-nvtx-cu12==12.1.105
+opencv-python==4.9.0.80
+packaging==23.2
+pandas==2.2.1
+pillow==10.2.0
+protobuf==4.25.3
+psutil==5.9.8
+py-cpuinfo==9.0.0
+pyarrow==15.0.2
+pydeck==0.8.1b0
+Pygments==2.17.2
+pyparsing==3.1.2
+python-dateutil==2.9.0.post0
+pytz==2024.1
+PyYAML==6.0.1
+referencing==0.34.0
+requests==2.31.0
+rich==13.7.1
+rpds-py==0.18.0
+scipy==1.12.0
+seaborn==0.13.2
+six==1.16.0
+smmap==5.0.1
+streamlit==1.32.2
+sympy==1.12
+tenacity==8.2.3
+thop==0.1.1.post2209072238
+toml==0.10.2
+toolz==0.12.1
+torch==2.2.1
+torchvision==0.17.1
+tornado==6.4
+tqdm==4.66.2
+triton==2.2.0
+typing_extensions==4.10.0
+tzdata==2024.1
+ultralytics==8.1.30
+urllib3==2.2.1
+watchdog==4.0.0
+pafy
+youtube-dl
+optuna