Upload 3 files

app.py

@@ -0,0 +1,129 @@
+import streamlit as st
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+import cv2
+import numpy as np
+from PIL import Image
+
+# Define the VanillaCNN_SE class
+class SEBlock(nn.Module):
+    def __init__(self, channels, reduction_ratio=16):
+        super(SEBlock, self).__init__()
+        self.global_avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc1 = nn.Linear(channels, channels // reduction_ratio)
+        self.fc2 = nn.Linear(channels // reduction_ratio, channels)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        batch_size, channels, _, _ = x.size()
+        y = self.global_avg_pool(x).view(batch_size, channels)
+        y = torch.relu(self.fc1(y))
+        y = self.sigmoid(self.fc2(y)).view(batch_size, channels, 1, 1)
+        return x * y
+
+class VanillaCNN_SE(nn.Module):
+    def __init__(self, num_classes):
+        super(VanillaCNN_SE, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.se1 = SEBlock(64)
+        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
+        self.bn2 = nn.BatchNorm2d(128)
+        self.se2 = SEBlock(128)
+        self.conv3 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
+        self.bn3 = nn.BatchNorm2d(256)
+        self.se3 = SEBlock(256)
+        self.conv4 = nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1)
+        self.bn4 = nn.BatchNorm2d(512)
+        self.se4 = SEBlock(512)
+        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
+        self.fc1 = nn.Linear(512 * 14 * 14, 1024)
+        self.fc2 = nn.Linear(1024, num_classes)
+
+    def forward(self, x):
+        x = self.pool(torch.relu(self.bn1(self.conv1(x))))
+        x = self.se1(x)
+        x = self.pool(torch.relu(self.bn2(self.conv2(x))))
+        x = self.se2(x)
+        x = self.pool(torch.relu(self.bn3(self.conv3(x))))
+        x = self.se3(x)
+        x = self.pool(torch.relu(self.bn4(self.conv4(x))))
+        x = self.se4(x)
+        x = x.view(x.size(0), -1)
+        x = torch.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+# Load the model
+@st.cache_resource
+
+def load_model():
+    model = VanillaCNN_SE(num_classes=12)  # Update num_classes as per your dataset
+    model.load_state_dict(torch.load("vanilla_cnn_se.pth", map_location=torch.device('cpu')))
+    model.eval()
+    return model
+
+model = load_model()
+
+# Define class names
+class_names = [
+    "Maize", "Common wheat", "Common Chickweed", "Loose Silky-bent",
+    "Charlock", "Cleavers", "Sugar beet", "Fat Hen", "Scentless Mayweed",
+    "Small-flowered Cranesbill", "Shepherd’s Purse", "Black-grass"
+]
+
+# Define transformations
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor()
+])
+
+def mask_image(image):
+    # Convert PIL image to OpenCV format
+    image_np = np.array(image)
+    hsv_img = cv2.cvtColor(image_np, cv2.COLOR_RGB2HSV)
+
+    # Define green color range
+    lower_green = np.array([30, 40, 40])
+    upper_green = np.array([90, 255, 255])
+
+    # Create a mask for the green area
+    mask = cv2.inRange(hsv_img, lower_green, upper_green)
+    masked_img = cv2.bitwise_and(image_np, image_np, mask=mask)
+
+    # Convert back to PIL image
+    return Image.fromarray(masked_img)
+
+def predict_class(image):
+    # Transform the image for the model
+    image_tensor = transform(image).unsqueeze(0)
+
+    # Predict the class
+    with torch.no_grad():
+        outputs = model(image_tensor)
+        _, predicted = torch.max(outputs, 1)
+        return class_names[predicted.item()]
+
+# Streamlit UI
+st.title("Plant Seedling Classification")
+
+st.write("Upload an image to classify the plant seedling and view the masked image.")
+
+# File uploader
+uploaded_file = st.file_uploader("Choose an image file", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    # Load the image
+    image = Image.open(uploaded_file).convert("RGB")
+
+    # Mask the image
+    masked_image = mask_image(image)
+
+    # Predict the class
+    predicted_class = predict_class(image)
+
+    # Display results
+    st.image(image, caption="Original Image", use_column_width=True)
+    st.image(masked_image, caption="Masked Image", use_column_width=True)
+    st.write(f"### Predicted Class: {predicted_class}")

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+torch
+torchvision
+opencv-python
+numpy

vanilla_cnn_se.pth

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