saideepm_koppula2_srijakod_project_final_deploy.py

import streamlit as st
import numpy as np
from PIL import Image
import torch
import torch.nn as nn
import torch.nn.functional as F
from PIL import Image


# Function to preprocess the uploaded image
def transform_image(file_upload):
    with Image.open(file_upload) as img:
        # Resizing the image to 64x64
        img = img.resize((64, 64))
        # Normalize pixel values to be between 0 and 1
        img_array = np.array(img) / 255.0

    return img_array

class VGG(nn.Module):
    def __init__(self, num_classes=43):
        super(VGG, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(64),

            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(64),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(128),

            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(128),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(256),

            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(256),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(512),

            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(512),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(512),

            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(512)
        )
        self.avgpool = nn.AdaptiveAvgPool2d((2, 2))
        self.classifier = nn.Sequential(
            nn.Linear(512 * 2 * 2, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x


# Creating a VGG model instance
vgg13_opt_model = VGG(num_classes=43)
vgg13_opt_model.load_state_dict(torch.load('best_vgg13_opt_model.pth', map_location=torch.device('cpu')))
vgg13_opt_model.eval()

class_names = ['Speed limit (20km/h)', 'Speed limit (30km/h)', 'No passing for vehicles over 3.5 metric tons', 'Right-of-way at the next intersection',
               'Priority road', 'Yield', 'Stop', 'No vehicles', 'Vehicles over 3.5 metric tons prohibited', 'No entry', 'General caution',
               'Dangerous curve to the left', 'Speed limit (50km/h)', 'Dangerous curve to the right', 'Double curve', 'Bumpy road', 'Slippery road',
               'Road narrows on the right', 'Road work', 'Traffic signals', 'Pedestrians', 'Children crossing', 'Bicycles crossing',
               'Speed limit (60km/h)', 'Beware of ice/snow', 'Wild animals crossing', 'End of all speed and passing limits', 'Turn right ahead',
               'Turn left ahead', 'Ahead only', 'Go straight or right', 'Go straight or left', 'Keep right', 'Keep left', 'Speed limit (70km/h)',
               'Roundabout mandatory', 'End of no passing', 'End of no passing by vehicles over 3.5 metric tons', 'Speed limit (80km/h)',
               'End of speed limit (80km/h)', 'Speed limit (100km/h)', 'Speed limit (120km/h)','No passing']


st.markdown(
"""
<style>
    .title {
        text-align: center;
        color: white;
        padding: 20px;
        background-color: #4CAF50;
        border-radius: 10px;
    }
    .result-container {
        text-align: center;
        margin-top: 20px;
    }
    .result-text {
        font-size: 24px;
        color: white;
        background-color: #4CAF50;
        padding: 10px 20px;
        border-radius: 5px;
    }
</style>
""", unsafe_allow_html=True)

# Streamlit web interface
st.markdown("<h2 style='text-align: center; color: black;'>Advanced Driver Assistance System(ADAS)</h2>", unsafe_allow_html=True)
st.markdown("<h3 style='text-align: center; color: black;'>Traffic Sign Board Recognition</h3>", unsafe_allow_html=True)

file_upload = st.file_uploader("upload an image", type=["jpg", "jpeg", "png"])

# Display the uploaded image
if file_upload:
    st.image(file_upload, width=200)
    if st.button('Click To Recognize'):
        # Preprocess the uploaded image
        image = transform_image(file_upload)
        image_tensor = torch.tensor(image.transpose((2, 0, 1)), dtype=torch.float32).unsqueeze(0)

        # Perform prediction
        with torch.no_grad():
            output = vgg13_opt_model(image_tensor)
            probs = F.softmax(output, dim=1)
            pred_class_idx = torch.argmax(probs, 1).item()
            pred_class = class_names[pred_class_idx]
        st.markdown(f"<div class='result-container'><p class='result-text'>Recognized Traffic Sign: {pred_class}</p></div>", unsafe_allow_html=True)