Duplicate from remotewith/dented_final

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

README.md

@@ -0,0 +1,14 @@
+---
+title: Dented Final
+emoji: ⚡
+colorFrom: pink
+colorTo: indigo
+sdk: gradio
+sdk_version: 3.33.1
+app_file: app.py
+pinned: false
+license: mit
+duplicated_from: remotewith/dented_final
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,249 @@
+### 1. Imports and class names setup ### 
+import gradio as gr
+import os
+import requests
+import torch
+import numpy as np
+from roboflow import Roboflow
+import cv2
+
+rf = Roboflow(api_key="gjZE3lykkitagkxHplyJ")
+project = rf.workspace().project("rideit")
+model = project.version(1).model
+
+from model import create_effnetb2_model
+from timeit import default_timer as timer
+from typing import Tuple, Dict
+
+file_urls = [
+    'https://www.dropbox.com/s/7sjfwncffg8xej2/video_7.mp4?dl=1'
+]
+
+def download_file(url, save_name):
+    url = url
+    if not os.path.exists(save_name):
+        file = requests.get(url)
+        open(save_name, 'wb').write(file.content)
+
+for i, url in enumerate(file_urls):
+    if 'mp4' in file_urls[i]:
+        download_file(
+            file_urls[i],
+            f"video.mp4"
+        )
+    else:
+        download_file(
+            file_urls[i],
+            f"image_{i}.jpg"
+        )
+
+
+video_path = [['video.mp4']]
+
+
+# Setup class names
+class_names = ["dented","good"]
+
+### 2. Model and transforms preparation ###
+
+# Create EffNetB2 model
+effnetb2, effnetb2_transforms = create_effnetb2_model(
+    num_classes=2, # len(class_names) would also work
+)
+
+# Load saved weights
+effnetb2.load_state_dict(
+    torch.load(
+        f="car_model.pth",
+        map_location=torch.device("cpu"),  # load to CPU
+    )
+)
+
+### 3. Predict function ###
+
+def normalize_2d(matrix):
+    # Only this is changed to use 2-norm put 2 instead of 1
+    norm = np.linalg.norm(matrix)
+    # normalized matrix
+    matrix = matrix/norm 
+    return matrix
+
+# Create predict function
+
+# Detect the image
+
+def detect(imagepath):
+
+    pix=model.predict(imagepath, confidence=40, overlap=30)
+    pix=pix.json()
+    img=cv2.imread(imagepath)
+
+    x1,x2,y1,y2=[],[],[],[]
+    for i in pix.keys():
+        if i=="predictions":
+            for j in pix["predictions"]:
+                for a,b in j.items():
+                    if a=="x":
+                        x1.append(b)
+                    if a=="y":
+                        y1.append(b)
+                    if a=="width":
+                        x2.append(b)
+                    if a=="height":
+                        y2.append(b)
+
+
+
+    for p in range(0,len(x1)):
+        x2[p]=x2[p]+x1[p]
+
+    for p in range(0,len(x1)):
+        y2[p]=y2[p]+x1[p]
+
+    for (x11,y11,x12,y12) in zip(x1,y1,x2,y2):
+        cv2.rectangle(
+                img,
+                (x11,y11),
+                (x12,y12),
+                color=(0, 0, 255),
+                thickness=2,
+                lineType=cv2.LINE_AA
+            )
+    
+    return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    #cv2.imshow("kamehamehaa",img)
+
+
+    
+
+
+    
+def predict(img):
+
+    start_time = timer()
+    
+    # Transform the target image and add a batch dimension
+
+    img1 = effnetb2_transforms(img).unsqueeze(0)
+    pix = normalize_2d(np.array(img))
+
+    #pix1=model.predict(str(image), confidence=40, overlap=30).numpy()
+
+    
+    # Put model into evaluation mode and turn on inference mode
+    effnetb2.eval()
+    with torch.inference_mode():
+        # Pass the transformed image through the model and turn the prediction logits into prediction probabilities
+        pred_probs = torch.softmax(effnetb2(img1), dim=1)
+    
+    # Create a prediction label and prediction probability dictionary for each prediction class (this is the required format for Gradio's output parameter)
+    pred_labels_and_probs = {class_names[i]: float(pred_probs[0][i]) for i in range(len(class_names))}
+    
+    # Calculate the prediction time
+    pred_time = round(timer() - start_time, 5)
+    
+    # Return the prediction dictionary and prediction time 
+    return pred_labels_and_probs, pred_time
+
+
+def show_preds_video(video_path):
+    cap = cv2.VideoCapture(video_path)
+    while(cap.isOpened()):
+        ret, frame = cap.read()
+        if ret:
+            frame_copy = frame.copy()
+            pix=model.predict(frame, confidence=40, overlap=30)
+            pix=pix.json()
+            x1,x2,y1,y2=[],[],[],[]
+            for i in pix.keys():
+                if i=="predictions":
+                    for j in pix["predictions"]:
+                        for a,b in j.items():
+                            if a=="x":
+                                x1.append(b)
+                            if a=="y":
+                                y1.append(b)
+                            if a=="width":
+                                x2.append(b)
+                            if a=="height":
+                                y2.append(b)
+
+
+
+            for p in range(0,len(x1)):
+                x2[p]=x2[p]+x1[p]
+
+            for p in range(0,len(x1)):
+                y2[p]=y2[p]+x1[p]
+
+            for (x11,y11,x12,y12) in zip(x1,y1,x2,y2):
+                cv2.rectangle(
+                        img,
+                        (x11,y11),
+                        (x12,y12),
+                        color=(0, 0, 255),
+                        thickness=2,
+                        lineType=cv2.LINE_AA
+                    )
+
+            
+            yield cv2.cvtColor(frame_copy, cv2.COLOR_BGR2RGB)
+
+
+### 4. Gradio app ###
+
+# Create title, description and article strings
+title = "Dented car Detector"
+description = "An EfficientNetB2 feature extractor computer vision model to classify images of dented or good cars."
+article = "(https://www.learnpytorch.io/)."
+
+# Create examples list from "examples/" directory
+example_list = [["examples/" + example] for example in os.listdir("examples")]
+
+inputs_image = [
+    gr.components.Image(type="filepath", label="Input Image"),
+]
+
+outputs_image = [
+    gr.components.Image(type="numpy", label="Output Image"),
+]
+
+
+inputs_video = [
+    gr.components.Video(type="filepath", label="Input Video"),
+
+]
+outputs_video = [
+    gr.components.Image(type="numpy", label="Output Image"),
+]
+
+
+# Create the Gradio demo
+app1 = gr.Interface(fn=predict, # mapping function from input to output
+                    inputs=gr.Image(type="pil"), # what are the inputs?
+                    outputs=[gr.Label(num_top_classes=2, label="Predictions"), # what are the outputs?
+                             gr.Number(label="Prediction time (s)")
+                            ], # our fn has two outputs, therefore we have two outputs
+                    # Create examples list from "examples/" directory
+                    examples=example_list, 
+                    title=title,
+                    description=description,
+                    article=article)
+
+app2=gr.Interface(fn=detect,
+                 inputs=inputs_image,
+                 outputs=outputs_image,
+                 title=title)
+app3=gr.Interface(
+    fn=show_preds_video,
+    inputs=inputs_video,
+    outputs=outputs_video,
+    examples=video_path,
+    cache_examples=False,
+)
+
+demo = gr.TabbedInterface([app1, app2,app3], ["Classify", "Detect","Video Interface"])
+
+
+# Launch the demo!
+demo.launch()

car_model.pth

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

model.py

@@ -0,0 +1,36 @@
+import torch
+import torchvision
+
+from torch import nn
+
+
+def create_effnetb2_model(num_classes:int=2, 
+                          seed:int=42):
+    """Creates an EfficientNetB2 feature extractor model and transforms.
+
+    Args:
+        num_classes (int, optional): number of classes in the classifier head. 
+            Defaults to 3.
+        seed (int, optional): random seed value. Defaults to 42.
+
+    Returns:
+        model (torch.nn.Module): EffNetB2 feature extractor model. 
+        transforms (torchvision.transforms): EffNetB2 image transforms.
+    """
+    # Create EffNetB2 pretrained weights, transforms and model
+    weights = torchvision.models.EfficientNet_B2_Weights.DEFAULT
+    transforms = weights.transforms()
+    model = torchvision.models.efficientnet_b2(weights=weights)
+
+    # Freeze all layers in base model
+    for param in model.parameters():
+        param.requires_grad = False
+
+    # Change classifier head with random seed for reproducibility
+    torch.manual_seed(seed)
+    model.classifier = nn.Sequential(
+        nn.Dropout(p=0.3, inplace=True),
+        nn.Linear(in_features=1408, out_features=num_classes),
+    )
+    
+    return model, transforms

requirements.txt

@@ -0,0 +1,7 @@
+torch==1.12.0
+torchvision==0.13.0
+gradio==3.1.4
+numpy==1.24.3
+roboflow
+opencv-python>=4.1.1
+requests